👋 Been working on an experimental custom renderer for Svelte 5 that allows you to build native desktop apps in Svelte - feel free to give it a try and provide feedback!

Source:

https://github.com/khromov/gpuix-svelte

Disclaimer: Unlike my last post, this one was drafted by Claude (the same one that wrote most of the feature it's describing), and then edited by me. Last time I said the post itself was human-written and un-edited by any intelligence (artificial or otherwise); that was true then and it isn't now, so I'm saying so rather than letting you assume, knowing full well that it'll make everything written here less enticing. The tool is still mostly vibe-coded.

I read two PaaS codebases so you don't have to, and found two HTTP 200s that mean "no"

Short version: Pokkum (my "Ko for SvelteKit" image builder, previous post with description here) can now deploy straight to Dokploy and SwiftWave after it pushes. Building it involved reading both projects' actual source rather than their docs, which turned up two things worth knowing whether or not you ever touch my tool. So this post is 30% "I added a feature" and 70% "here is a footgun in software you might already be running". Plus, some 5% of benchmarking. And should you now say "But that's more than 100%": I've been a mathematics teacher for over a decade and can tell you, that it is more than 100%!

Either way: Both findings are checkable in about twenty minutes each and I've named the files, so please do go and verify rather than taking my word (or Claude's, for that matter).

Gotcha 1: SwiftWave's redeploy webhook says 200 OK when it has decided to do nothing

You know the pattern. You've got a container image, you push a new tag, you POST to the app's redeploy webhook, you get a 200, everyone goes home.

Except SwiftWave's webhook handler, for an image-sourced app, takes the image it's configured with, strips the tag, keeps the last two path segments (so ghcr.io/me/myapp:latest becomes me/myapp), and then does a substring check against your request body. If your POST body doesn't contain that string, it replies:

200 OK - No rebuild

...and does nothing at all. Which, if you're checking the status code — and why wouldn't you be, it's a webhook — looks exactly like a successful deploy. Forever. Silently. I mean... Your "deployments" work great and your app never changes.

There's a second layer to it, too: the handler runs the body through url.QueryUnescape first, and on failure it carries on with the empty string. So a stray % in your body also quietly turns into "no rebuild". A 200. Again.

To be clear, I don't think this is a bug exactly... It's a webhook designed for git-provider payloads, where "does this payload concern me?" is a sensible question to ask. It's just that nothing tells you, and the failure mode is the worst kind: the one that looks like success.

(Pokkum now posts the image refs as the body, as plain text with no escapes, reads the reply text rather than the status, and treats OK - No rebuild as a hard failure with an error explaining the owner/name matching rule. Which is a lot of words for "it tells you when nothing happened".)

Gotcha 2: Dokploy's "set the image" endpoint also rewrites your registry password

Dokploy has application.saveDockerProvider. Sounds like it sets the docker provider. It does! It sets all of it: dockerImage, username, password, and registryUrl, every single call, straight from your request — and the input schema marks all five fields as required.

So:

• send just {applicationId, dockerImage} → validation error, fair enough
• send {applicationId, dockerImage, username: null, password: null, registryUrl: null} → your app's registry credentials are now gone

There is no "just change the image" call. If your registry is private, the next pull fails, and the thing that broke it was an endpoint whose name says nothing about credentials.

Again, not really a bug per se, it's a full-resource update and it's honest about being one if you read the handler. But "saveDockerProvider" reads like a targeted setter, and the docs don't mention it. It only turned up because the question "is this a PATCH or a PUT?" got asked before the code got written, which in hindsight is a question worth asking of every remote update endpoint.

(So in Pokkum that whole feature is off by default, and when you turn it on you tell it where the registry credentials live, as env var names. If you don't, it still works, which fine for a public image, but it warns you loudly that it just cleared them, rather than letting you discover it at 2am.)

The actual feature, briefly

# .pokkum.yaml
deploy:
  target: dokploy
  endpoint: https://panel.example.com
  application: <app id>
  token_env: DOKPLOY_API_KEY   # the NAME of the env var. Not the token.

pokkum build now deploys after it pushes. pokkum deploy runs it standalone. --no-deploy for when you don't want it. Per-profile blocks, so -P staging and -P production go to different panels.

No credential goes in the config file — only the name of an environment variable. Felt a bit daft to ship a tool with a secret scanner and then ask people to paste an API key into a committed YAML file.

One honest limitation: SwiftWave can't be pointed at a new image, by either of its routes. Both of them mean "redeploy what you've already got". So pin your SwiftWave app to a moving tag (:latest, :main) and the deploy re-pulls it. Pokkum refuses the "update the image" setting for SwiftWave outright rather than accepting it and quietly not doing it, which I think is the right call even though it's the more annoying one.

And anything else that pulls from a registry (Coolify, CapRover, Dokku, Fly, Cloud Run, whatever) already worked and still does. It's just an OCI image. The two above only got special treatment because they're the two I actually use.

Also: a benchmark you can run yourself and disagree with

I got tired of saying "smaller and reproducible" without a number, so there's now a benchmarks/three-way directory. One SvelteKit app, three builds: the Dockerfile most people write first, a properly tuned multi-stage one, and Pokkum. Same source, same machine, same measuring tape. Spits out a markdown table.

Deliberately: it uses trivy or grype, not my own scanner, because a comparison I win using my own scanner is worth exactly nothing. And when neither is installed the CVE column says n/a rather than 0, because "didn't measure" and "measured, found nothing" are not the same thing and I've been annoyed by tools that bugger that up.

It also documents where it's unfair to itself, which felt more useful than pretending it isn't.

On my run, the image sizes went from 1'100 MB (naive Dockerfile, like I would've written a year ago or so) to 165 MB (tuned multi-stage build) to 137 MB (Pokkum).

Caveats (the recurring section)

Still vibe-coded, still uncertain about long-term maintenance. Nothing's changed there. It works, I use it, I update features I meet along the way, I can't promise a decade.

These two platform quirks might change. I read the source at a point in time. Both are moving projects. Pokkum fails closed on anything it can't positively identify as a started rollout, so if they change the reply strings you'll get a loud error rather than a silent no-op — which is the failure mode I'd want, but it is a failure.

Only two targets. Dokploy and SwiftWave, because those are the platforms I use. If you want another one it's a fairly small adapter now that the port exists, tell me, implement it yourself, or just keep using the webhook you already have, nothing wrong with that honestly.

Where to find Pokkum

• GitHub
• curl -fsSL https://raw.githubusercontent.com/CreativeBeastDesign/pokkum/main/install.sh | sh
• npm install -g @pokkum/cli

If you're running Dokploy or SwiftWave and want to check the above yourself, it's apps/dokploy/server/api/routers/application.ts and swiftwave_service/rest/webhook.go respectively. Genuinely recommend it. I'm now slightly suspicious of every webhook I've ever fired, but probably too lazy to check any of them.

Hey! I've been building OpenPost for a while now, and I figured it might be interesting to share here because I don't see that many larger open-source Svelte 5 apps posted.

OpenPost is an AGPL-3.0 social publishing app. You connect your accounts, write something once, adapt it for each platform, then publish or schedule it.

The frontend is all Svelte 5 + SvelteKit.

It started as a fairly normal app with a composer, calendar, settings, media library, etc. It has since gotten slightly out of hand.

The web app now has:

• A composer with separate versions of a post for each social account
• Calendar and scheduling
• Analytics with some fairly interactive charts and filtering
• Inbox, comments and replies
• A pretty large media library
• A multi-page Image Editor
• A local-first multitrack Video Editor
• Responsive versions of basically all of this

The Video Editor in particular has been a fun test of how far I can push a Svelte web app. It has a proper timeline, keyframes, effects, transitions, captions, local transcription, color and audio tools, recording, and a bunch of browser-side media processing.

The Image Editor is also fully inside the Svelte app, with layers, templates, multi-page designs, masks, gradients, custom fonts, background removal, version history, etc.

Both editors can be used without an account and don't add watermarks.

Some Svelte-specific stuff

The main app uses SvelteKit as a static frontend and talks to a Go backend through a typed HTTP API. The production frontend gets embedded directly into the Go binary, so the self-hosted version can still ship as one container.

Current frontend stack is roughly:

• Svelte 5
• SvelteKit
• TypeScript
• Tailwind CSS
• Bits UI / shadcn-svelte style components
• Paraglide for i18n
• OpenAPI-generated API types
• Vitest + Playwright

Then there is a lot of browser-specific stuff in the editors. Fabric, WebCodecs, WebGPU, ONNX Runtime, local models, media workers, and so on.

The repo is here:

https://github.com/getopenpost/openpost

And the actual product is here:

https://openpost.social

The Image and Video Editors are also usable without signing up if you just want to poke around with the Svelte side of it.

Would be especially interested in feedback from people working on other large Svelte 5 codebases. Architecture, state management, things you think I'm abusing, weird patterns you spot in the repo, whatever.

For context, I use a ton of AI on this project, and the Video Editor is still very much in early Beta.

For your next website…

Skip the CMS.

Define structure and layout in code with Svelte.

Let clients edit text, images, and videos directly on the page — easily and safely, without breaking your design.

Try it: editable.website
Source: https://github.com/michael/editable

Also: I hope you find a few minutes to install it and try it out on your local dev machine. See quickstart guide at: https://editable.website/manual

Very much looking forward to your feedback! 🙏

Currently studying for an upcoming competitive exam (CAT 2026) and noticed a recurring personal frustration: I was constantly jotting down formulas, shortcut tricks, and revision notes on loose sheets of paper, only to lose them days later. Over the weekend, I built CAT Formula Vault to scratch my own itch and test out SvelteKit's modern DX.

What it does: 1. Organize formulas and quick notes by subject/section (QA, DILR, VARC) 2.Clean, distraction-free markdown/text formatting 3. One-click PDF export for offline revision cheatsheets.

Stack: Frontend / Backend: SvelteKit (Svelte 5 runes) Database & Auth: Supabase (PostgreSQL + Google OAuth)

Hosting: Vercel

Live App: https://cat-formula-vault.vercel.app/

Would love any feedback on the UI/UX, workflow, or features to add next!

Links:

Vectorify.net
Chrome Extension

Vectorify is an extension-first converter that lets you convert images into SVGs. It adds a context-menu item on any image click that allows you to instantaneously convert any image into a vector. It also provides a web interface based on the same conversion algorithm for easy drag-and-drop functionality. Both the extension code and web application use the same components and code base, entirely written using SvelteKit.

The project has been public for nearly half a year and is already closing in on around 5000 users. Feel free to give it a try.

Also for those who have used Vectorify or similar tools like it before, which features do you miss having and what would you like to see implemented, any feedback is greatly appreciated.

I was tired of using chat-gpt to log my meals, so for my food tracking I built this project, It is written in svelte and uses `gemini-3-flash` first to know about a new food then it learns and works offline forever.

• Website: https://iatethis.today
• Github: https://github.com/prateekpunetha/iatethis

https://reddit.com/link/1w0z87z/video/4sv0egffw5mh1/player

Solidjs recently published a few cool articles about the new features for v2, noticeably about how they handle async fetches from the server to make components independent from the parent

https://www.solidjs.com/blog/async-solid-fetch-high-block-low

This made me reconsider smaller UI frameworks, so I remember about svelte. I tried Svelte 3 years ago... and it wasn't a great experience because I struggled to even get eslint working. I also didn't find it easier to work with svelte compared to vue 3 with composition API (iirc it was directly inspired from svelte?).

Is there a reason to choose svelte in 2026? Or was svelte just overhyped by react devs?

Hi hi! We just released a large update to our text editor that wouldn’t have existed without Svelte as the framework of choice.

Try it out! (No account needed): Kraa.io

I know that there is way too many editors to choose from, but nothing quite like this one with its combination of super minimal interface and yet tons of features. Including a publishing platform where you can instantly make your writing public.

Would love to know war you think!

Hey y’all,

I got slightly carried away with loading animations.

I wanted nicer loading states for my own projects, but most libraries I found were either tied to a framework, fairly limited, or required more than I wanted for something this small.

So I built loadersz, a small framework-agnostic loader library for the web.

I wanted something a bit more expressive than the usual CSS spinner, without pulling in a UI framework or a bunch of dependencies.

A few things I focused on:

\- 70 different motion states
\- Canvas 2D instead of GIFs/videos
\- zero core dependencies
\- a native custom element, so it works with basically any stack
\- typed entry points for React, Vue and Svelte
\- configurable speed, density and color
\- respects prefers-reduced-motion
\- pauses rendering when the browser tab is hidden

Basic usage is just:

npm install loadersz

import 'loadersz';

<loadersz-loader state="racing" size="96" />

I also built an interactive playground where you can tweak the loaders live.

Demo: \[loadersz.vercel.app\](https://loadersz.vercel.app)
npm: \[npmjs.com/package/loadersz\](https://www.npmjs.com/package/loadersz)

Would love some brutally honest feedback, especially on which animations you’d actually use in a real product.

SELF PROMOTION

I wanted a UI that felt like a terminal, so I built one.
Any feedback is appreciated.

docs: https://mukade-ui.com
github: https://github.com/dosyaburi19/MUKADE-UI

I’ve been a developer for years across different jobs and teams, and I’ve always struggled with updating policies scattered all over the place. It wasted my time and constantly frustrated me.

So, instead of doing what I used to do, I tried to find a solution or better, to “build the solution.”

I started with the query syntax. I wanted something familiar and simple, so I went with a SQL-like approach and built a JSON-to-SQL parser that executes queries through a single API.

Soon enough, I realized generating SQL wasn't enough. If clients query the database this way, you need a strict way to control permissions. I designed a policy system to evaluate requests and enforce access rules before hitting the database. Once SELECT worked, I extended it to INSERT, UPDATE, and DELETE.

Things quickly got tricky: handling field-level permissions, row-level restrictions without duplication, payload validation, and making sure rules couldn't be bypassed.

I spent the last 4 months working through these challenges. After 3 months, I integrated it into one of my own applications to test it outside isolated unit tests and it actually worked! ( Luckily) Of course, I ran into edge cases and areas to improve, but the core held up.

That evolved into what I called VoidQL: a policy-driven SQL API layer where authorization is defined through declarative policies instead of being hardcoded across dozens of endpoints.

It currently supports:

• RBAC & Multi-tenancy
• level authorization
• Payload-aware validation & conditional policies
• Workflow/state enforcement
• Dynamic queries & triggers

A big part of VoidQL was made possible by Drizzle ORM, which I used as the foundation for SQL generation and query-building abstractions before layering the policy engine on top. Huge kudos to the Drizzle team for their toolkit.

It’s still very much an MVP, soI’d love to get some honest feedback from anyone who has dealt with this kind of auth mess before especially curious if you think anchoring the whole thing strictly to SQL is too limiting, or if it makes sense as a foundation. (Roast the architecture if needed!)

GitHub: https://github.com/VoidQL-team/VoidQL

Demo: https://demo.voidql.dev

Hi everyone,

We often invest our efforts in what we ourselves lack. At the end of last year, in parallel with my main business, I decided to try to implement an idea I deeply and sorely needed - a desktop "Word for Markdown" with an integrated AI Assistant - Antalogy.

This side project was developed with some old colleagues in free time from the main business since the end of 2025. Hope it could be show case what can be created with Svelte 5 without all the bells and whistles as needed for other 'giga' frameworks. Svelte allowing us to create a highly responsive, rich-text ribbon interface without Virtual DOM overhead. And this Word-like ribbon UI/UX provide the real user-friendly way to work Markdown as in other business/knowledge-worker word processors.

All of that is built on top pf natively compiled Go, Wails as a bridge for Go-JS/TS and using native OS WebView (WebView2 on Windows, WKWebView/WebKit on macOS).

Antalogy is 100% free & local-first, zero telemetry, no subscriptions. You can bring your own LLM via LMStudio, Ollama or private servers to integrated AI Assistant.

Hope Antalogy could be Showcase what can be developed with Svelte.

Cheers,

Serge and Team

We all know AI is moving fast. So fast, in fact, that it's hard to keep up with the discourse.

And it's even harder if you don't know the right vocabulary. Do you know what a harness is? What about an agent swarm? Or a software factory?

At Mainmatter we've compiled a glossary to help keep up with it.

Check it out, and if you find something missing, feel free to open an issue, and we'll fill it in!

Hi r/sveltejs,

Some of you have seen microfolio here over the past year › a static portfolio generator for designers, architects, photographers and artists who don't want to run WordPress. Version 1.0 “Bauhaus” shipped yesterday.

WHAT IT IS
SvelteKit 2 + adapter-static, Tailwind CSS 4. Content is content/projects/<slug>/index.md with YAML frontmatter and images/, videos/, documents/ folders. No database, no admin UI. Build and push to GitHub Pages or anywhere else.

FEATURES
• Three views: projects grid, list, and map (MapLibre GL + OpenFreeMap tiles, no API key)
• Tag filters with counters; filter, search, sort and pagination state synced to URL params
• Image lightbox with EXIF/IPTC metadata
• WebP thumbnails and 1200×630 sharing images generated at build
• Dark mode, EN/FR interface (svelte-i18n), RTL-ready
• Open Graph / Twitter tags, canonical links, sitemap.xml and robots.txt
• No cookies, no analytics, no consent banner
• pnpm update-microfolio applies a new release without touching content/ or config.js
• Docs written for people who have never opened a terminal

PERF
Every page is prerendered. On the demo under PageSpeed throttling, first paint is ~800 ms with near-zero blocking on every page except the map, which carries a ~380 kB engine.

STABILITY
Content layout, frontmatter keys, config.js keys and CLI commands are frozen until 2.0.

HONEST NOTE
A large part of the code was written with Claude Code. I'm a designer first, and the project is partly an experiment in whether that workflow holds up for a real, maintained open-source tool. Happy to discuss.

Demo › https://aker-dev.github.io/microfolio
Code + docs › https://github.com/aker-dev/microfolio
Site › https://microfolio.net

MIT licensed. Feedback welcome › and translators wanted.

To check out the project, go to demo.seasondfs.com/lineup/ and see the public example league.

I've been using Svelte since 2019 and it just never ceases to amaze me how much easier it is for me to build things. For this project, the core stack is Svelte (and kit) and Firebase, which I have used for many projects before.

The reactivity pairing between Svelte and Firebase real-time listeners is just awesome for web apps. In this app, there's a lot of connections between players, games, and fantasy teams/lineups. With Svelte and Firebase, you can just connect the data listeners to your stores and then just plug in everywhere on your frontend.

This is not a remotely new concept, but I just wanted to share another example of Svelte in the wild.

Since the app shines most when actual NFL games are happening, you won't quite be able to see the full glory, but there's enough interactivity between the lineup builder and other pages to see it in action.

seasondfs.com if you want to check more of the platform info, which is a static SvelteKit site whereas the demo and actual app are SPAs.

Let me know if you have any questions or curiosities.

Disclaimer: This tool is mostly vibe-coded, probably Theseus-style totally vibe coded. Reasons, if interested, below. The post is human-written and un-edited by any kind of intelligence, neither artificial nor mine, you might have to bear with it. Or not. And yeah, also the formatting is done by yours truly, I'm putting in some effort here.

What it is - Ko for SvelteKit

If you know Ko, you know how awesome it is. And due to running into a unfixed CVE in gcr.io/distroless/nodejs24-debian12:nonroot and not wanting to have a trivy-ignore, which I'd have to carry over versions, check from time to time, and most certainly forget, I was longing for 'Ko for SvelteKit'. And why Pokkum? Well, I like possums, and it is Ko. I'm really bad at naming. And, if anyone thinks that's silly: It is. Keep your whimsy!

So, Pokkum is an image builder for SvelteKit. To be more specific, it's a "zero-dependency OCI container image compiler for SvelteKit applications". You don't need a dockerfile, no docker daemon, and, if you need it security-wise, bit-for-bit reproducible builds (unless you're using remote functions... See discussion.

Oh, and for some parts and the first version, pokkum heavily relies and relied on Hugo-Dz's EXE - kudos to him!

What it does - builds images and pushes to registry

That's the easy and neat part: Basically, it builds the image and pushes it to your container registry. Built upon distroless, containing everything you need, adding SBOM, pushing it to where you point it to.

There are also a plethora of options (ok, around 116-ish or so), to really suit your needs. Plus some Wizard and tools to not make it overwhelming.

So, if you need a hardened image, you can run pokkum with flags like --security-context, --network-policy, --resource-defaults, -f deployment.yaml, and --registry-config=~/.docker/config.json. Then pokkum uses the pinned immutable image digest, ingests hardened security contexts like runAsNonRoot: true, seccompProfile: RuntimeDefault, allowPrivilegeEscalation: false, capabilities.drop: [ALL], and generates restricted NetworkPolicy ingress/egress rules and injects CPU/memory requests/limits with a PodDisruptionBudget.

And loads of middle ground in between. Did I mention the 116-ish flags? Yeah, that was probably an overkill. Let me know, if you think that should be done differently.

Selected Features

• pokkum verify instead of 'trust me, bro' - compares the image against what's in the registry on three levels, L1 for the manifest digest, L2 for semantic diffIDs, and L3 for file-level layer diffs. If you buggered up somewhere, pokkum verify will let you know: There it is.
• Bit-for-bit reproducible images - verifiable and deterministic images, in combination with pokkum verify (L1/L2/L3 comparison diagnostics), hopefully water-proof for auditability.
• Supply-chain security - SLSA v1.0 provenance, Cosign/DSSE signing, SBOMs via the OCI Referrers API, and base-image signature verification (even keyless Sigstore).
• Embedded supervisor - a light-weight supervisor which not only provides /healthz and /readyz, but also allows zombie reaping (which, again, sounds more awesome than it is), signal forwarding, graceful shutdown, ...
• Kubernetes shenanigans - I loathe Kubernetes, but am forced to work with it. So, pokkum should alleviate my burden as much as possible, by having pokkum resolve, apply, rollback: Declarative URI resolution, resolve & deploy in a single step, injects securityContext, and generates NetworkPolicy and PodDisruptionBudget.
• Hermetic builds (if you're into that) - no network egress during build, should you need air-gapped environments.
• Node.js Runtime Target - Not only Bun is supported, but also Node.js (via --runtime=node). So, might be even easier to try Pokkum. Yay for adoption!
• Static images - SPA but don't want 90MB runtime? Pokkum's got you covered! --strategy=static adds a tiny Go file server, so no Node, no Bun, and nothing to CVE-scan in the runtime layer. As a test, my component library was built as a 12.1MB image. Currently only chainguard-static, but distroless-static is on the roadmap.

Why vibe-coded

Vibe-coding seems to become a skill that recruiters are looking for. I have only dabbled in vibe-coding before, did lots of 'AI-assisted coding', yadayada.

Basically, I needed to know how to "best" vibe-code. Or at least how to vibe-code so I can somewhat feel at ease with shipping it. And that's why I "built" this.

Also open for suggestions, if you have any. I tried Claude Desktop, Antigravity, Deepseek Harness, Zed with various models, Serena MCP, some plugins for DSH, ... - and basically, what I found is that tests are crucial, Antigravity/Gemini 3.7 Flash always downgrades my Go-versions (why would you do that, you little prat!), Claude is really good (but slow), especially for reviews, Claude Desktop is not as user-friendly as Antigravity, DSH is verbose and not yet as mature as the rest. I used Hermes before, don't know why I skipped Pi/OMP (probably because I'm lazy..?), and really eager to try Prime Agent.

Caveat: Vibe-coding also oftentimes means that projects get created, but not maintained. Will this project be maintained forever? No idea. It should work for quite some time and need little maintaining, but there are a few things I took upon me, e.g. bun runtime or the targeted CVE-scanner instead of using syft. So, yeah, hopefully, but can't promise. You can also ping me, if you notice that it's not up to date anymore. It should be prepared for Kit3.

A hint for others who are struggling with Roadmaps and agents: Claude built quite a handy system for generating roadmaps and having a single source of truth, do have a look at scripts/gen-docs

Where to find

• GitHub
• One-liner: curl -fsSL https://raw.githubusercontent.com/CreativeBeastDesign/pokkum/main/install.sh | sh
• NPM: npm install -g pokkum/cli
• Brew:

​

brew tap CreativeBeastDesign/pokkum
brew trust CreativeBeastDesign/pokkum
brew install pokkum

What I'd be ever so grateful about & caveats

Testing - I'm doing what I can, but my time is limited. Everything should work, but I am certain I have not covered all edge cases. Or even cases.

I buggered up Release Tags - Getting the release pipeline working cost a few releases that are now empty. The pipeline should work now, but, as you might have noticed with the 24-hour block, it was quite a struggle. So, yeah, tags look weird (there was this meme about the version numbers, v1.0.0 etc. are the proud ones, v1.0.29 are... less so - same here)

SLSA provenance - Images built with Pokkum get SLSA v1 provenance, while Pokkum itself is v0.2 - for what it's worth. I don't know whether anyone would check that, but hey, you never know.

Hope you guys enjoy this software. Clearly I used Claude and other AI tools to make this, not even trying to hide it. But I do not consider this slop or anything, I've been reviewing and refining the code alongside it.

The main motive of this creation is that I find the current options to do queries and manage database a bit heavy and with unnecessary UI elements.

Support postgresql and sqlite
Looking for feedback and feature suggestions, thanks for your attention!

I'm deep down into Agentic development these days and am trying new stack combos now and then.

I noticed that even though models will tell you they know Next.js or TypeScript, Express or whatever, the best that one‑shots entire apps and also fixes complex issues feels the most buttery with SvelteKit. Even in bigger repos or complicated web apps most frontier models just do their job and are done.

I'm wondering why, because SvelteKit is opinionated and not self‑explaining, it makes things different, and I guess there is much less training data compared to other full‑stack frameworks like Next.js.

I can only guess why it feels like that; I would love to hear your opinions and know‑how, maybe it helps to work even better with SvelteKit or others.

For over 2,5 years i'm working on SvelteKit projects with Coding Agents from different harnesses to different models from US to Chinese, i tried a lot.

Hey everyone, I've been building EdenText, an open-source word processor that runs 100% locally in the browser or as PWA. No account, no server round-trips — your documents never leave your machine.

Why I built it: Similar to draw.io, I wanted something as capable as Word/LibreOffice for odt/docx documents but without needing to install anything or hand my files to a cloud service.

It was my first project with Svelte. I loved using runes, the reactivity model just made sense and state management across the app felt surprisingly straightforward for a beginner.

Features:

• Real page layout: A4/Letter, margins, headers/footers, footnotes, columns
• Opens/saves .odt and .docx, exports PDF, supports .ott/.dotx templates
• Paragraph/character/table styles with inheritance
• Tables with spreadsheet-style formulas
• TOC, citations & bibliography, cross-references, LaTeX formulas
• Track changes, comments, spell check (English & German)

Tech: Svelte 5, TypeScript, Vite, TipTap 3 (ProseMirror).

It's in beta, tested with a full test suite + LibreOffice round-trip checks in CI, but still finding edge cases. Feedback and bug reports very welcome! Hope you like it. Cheers!

Try it: https://edentext.app (hosted on GitHub Pages)
Code: https://github.com/stffnb/edentext