In my recent open source electron app, which is a coding agent for embedded devices powered by OpenCode, I’m using Svelte for the UI and honestly it has been a really good experience.

The app is desktop-focused and includes things like a code editor, chat interface, serial monitor/plotter, board management, and workspace/project handling. There are a lot of moving parts in the UI, and Svelte has made it much easier to keep things manageable without the code feeling overly heavy.

What I like most is how direct everything feels. State updates, component structure, and UI reactivity are just easier to reason about. For an app like this, where I’m constantly wiring together interactive desktop features, that simplicity matters a lot.

I’m also using Tailwind alongside Svelte, and the combination has been very productive for building the interface quickly while still keeping it maintainable.

Repo: https://github.com/Razz19/Exort

Hey folks, I built a Svelte version of Paper-style shaders and just released it as OSS.

It’s called `@devmischief/shaders-svelte`.

- All Paper shader effects (gradients, noise, dithering, glass/liquid styles, etc.)

- interactive demos for each shader

- copy-paste usage snippets

- built for Svelte + SvelteKit

I made this because I wanted the Paper shader look/feel in Svelte without extra setup complexity.

Would love feedback on:

1. API naming

2. performance on lower-end devices

3. which shaders/features I should add next

Demo: https://shaders.devmischief.com

npm: https://www.npmjs.com/package/@devmischief/shaders-svelte

Repo: https://github.com/manuelogomigo/paper-shaders-svelte

I have a dataset of 4K shadcn-nextjs components (website sections, UI components, etc.) and I'm working on converting them all to Svelte for a fine-tuned local code generation model.

Background:

• Already fine-tuned a Qwen model for Next.js components (iamdyeus/qwendean-4b-GGUF)
• Runs locally with <8GB VRAM
• Building an Electron app for local v0.dev-style code generation
• Will open-source the app + training data once my papers are published

Someone on r/LocalLLaMA suggested making a Svelte version, so here I am!

The Plan: I'll use GLM 5.1 (Got credits, that's why using it) to synthetically convert the entire dataset from Next.js/shadcn-ui to Svelte/shadcn-svelte. But I want to make sure the conversion handles Svelte-specific patterns correctly.

What I need help with:

1. What are the critical differences I should ensure the model captures when converting from Next.js → Svelte? (Beyond the obvious like className → class, .map() → {#each}, etc.)
2. Svelte-specific gotchas that might not be obvious to someone coming from React?
3. Best practices for shadcn-svelte components that differ from the React version?

Bonus ask: If you have any Svelte components/sections built with shadcn-svelte that you'd be willing to contribute to the training dataset, please drop a GitHub link below! More diverse real-world examples = better model. 🙏

Really excited to bring local focused code generation to the Svelte community!

Thanks

Hi everyone ...

I wanted to share a small tool I've built to help me monitor my various personal projects on the Hetzner cloud. I've called it Serverwat.ch. I've built it on top of Sveltkit so thought this community might interested.

The problem statement: I have a bunch of servers on Hetzner and they are organised across multiple projects. If I need to routinely look at their health and check their CPU/network/disk utilisation levels over time I need to individually choose a project, then choose a server and look at the graphs and repeat. With multiple projects with multiple servers in each, this is far from convenient.

To simplify it I built a simple dashboard for myself where I can see graphs for all my servers from all my projects on one screen.

I have decided to publish it online for others to use.

This is a simple Web app hand-coded with Sveltekit, Tailwind CSS and Shadcn which runs entirely client-side in the browser. Nothing is sent to the Serverwat.ch server and the app in the browser directly accesses the Hetzner API. Users simply provide read-ony Hetzner API keys for each of their projects which remain in the browser.

With the app users can:

• Monitor CPU, network (packets/s or bytes/s) and disk (iop/s or bytes/s) utilisation
• Set refresh frequency from one minute up to 15 minutes
• See data from the last 15 minutes up to the past week
• Filter the servers by Hetzner data centre location, tags applied to servers in the Hetzner console, and Hetzner project

When users add the read-only keys for their projects they are stored locally in the browser's local storage so they are available the next time the user uses the app. The keys are never sent to the Serverwat.ch server.

Feel free to check out the tool at:

https://serverwat.ch

It won't set or collect personally-identifiable cookies or collect any user-identifiable information. Your read-only tokens won't be sent to the server and the server won't see any information about your Hetzner servers.

For transparency, I am looking at wrapping this in Capacitor to add notification capabilities and other features in a mobile app and offering that in the Android and iOS app stores. None of that changes the principles outlined for the Web app above.

As mentioned in my other post, I am moving away from Wordpress and towards a custom CMS for my agency's client base. The visual page building experience of Elementor is something our clients love, and I want to maintain it for our workflow and their use.

Over the past few days I've made quite a few edits and polish that I think brings this builder up to a very usable point and you may want to integrate it into your own CMS projects. (or even contribute / suggest changes to the repo)

The live builder demo is available at https://visualbuilder.org/ where you can try all the features, html import, Elementor template import, AI building and editing, etc.

If you try it out, i would love your feedback!

Highlights

• Visual drag-and-drop editor with canvas selection, action rails, structure navigator, inspector panels, undo/redo, copy/paste, and paste-style support.
• Svelte runtime renderer for published pages, with editor-only code kept separate from runtime-only routes.
• Host-first SDK contracts for persistence, media, permissions, dynamic data, AI settings, and lifecycle hooks.
• Template import for native Builder package JSON and Elementor JSON.
• HTML/CSS import that converts common markup into editable Builder nodes and preserves complex markup as safe HTML fallback nodes.
• AI create/edit workflow with OpenAI-compatible provider settings, debug mode, HTML-based creation, and safer semantic editing tools.
• Dynamic data bindings for text, rich text, URLs, media, colors/styles, numbers, attributes, visibility, and host-provided providers.
• Media library contracts and reference upload/select flows.
• Draft, autosave, publish, revision, and restore contracts with reference SvelteKit behavior.
• Dense document and drag/reorder testing, including 200/500-node fixtures.

You can find the docs / embedding instructions here:
https://github.com/BluePointDigital/svelte-visual-builder/tree/main/docs

Thank you!

I’ve been working on a project called Worklog, a desktop project manager designed for small dev teams that don’t want to rely on cloud tools.

The idea is simple: fast, keyboard-driven planning with a Kanban workflow, and all data stored locally. No accounts, no sync servers, no hidden state.

Core structure:
Workspace -> Board -> Ticket

What it currently does:

• Kanban boards (Todo / In Progress / Done)
• Ticket editing with comments
• Command palette + keyboard shortcuts for most actions
• Persistent workspaces that restore on startup
• Local SQLite storage (your data lives in your workspace folder)

Key decisions:

• Local-first by default (works fully offline)
• No forced cloud or SaaS model
• Data is transparent and portable
• Git-friendly direction for teams that want versioned project state

Tech stack:

• Tauri (desktop shell)
• SvelteKit + TypeScript
• Bun
• SQLite

Architecture is straightforward:
UI -> hooks -> repository layer -> SQLite

What I’m trying to avoid:

• Turning it into another bloated PM suite
• Locking users into a hosted backend
• Hiding data behind APIs or proprietary formats

Planned direction:

• Better filtering and board views
• Richer ticket metadata
• Search across workspaces
• Backup/export workflows
• Git-native workflows for teams

This is still early, but already usable for small projects.

I’m interested in feedback from people who:

• Prefer local-first tools
• Are tired of Jira/Linear-style overhead
• Care about data ownership

Repo: https://github.com/regisx001/Worklog

Latest Release : https://github.com/regisx001/Worklog/releases/tag/app-v0.3.0

don't forget to give a star in github !!!

Dialyma is an open-source alternative to Framer - built for developers who want the speed of visual design without losing control over their code.

You can design your UI visually and export clean, production-ready HTML & CSS for free. No messy divs, no locked platform, no weird abstractions - just code you can actually use.

Dialyma also supports plugins to export directly to React, Next.js, Vue and Laravel. So you can start simple, and scale into real apps without switching tools.

The goal with Dialyma is simple:

make visual building feel fast like modern tools, but keep the output developer-friendly.

GitHub: https://github.com/dialymaai/dialyma

Any kind of Support, feedback, issues, and contributions are welcome.