electron-shadcn is a desktop app template with the whole stack already wired

A template, and the promise in its description

The README sets the expectation directly. Electron in all its glory, everything you will need to develop your beautiful desktop application. The stated reasoning is practical. To develop an Electron app you probably need some UI, test, formatter, style or other kind of library or framework, so the author installs and configures a set of them. That framing also sets the limit of the project. This is a starting point that makes a set of choices for you, and the choices are visible and dated, which means the interesting question for an adopter is not whether the stack is good but whether it is a stack you would have chosen yourself. The list is long and the versions are current, which is both the appeal and the maintenance cost.

The library list, and what each group is for

The README groups the choices, and the grouping is a decent guide to the intended shape of an application. The core is Electron 43 and Vite 8. The developer experience layer is TypeScript 6, oRPC, Prettier, Ultracite with Biome, Zod 4 and React Query from TanStack. The UI layer is React 19.2, Tailwind 4.3, shadcn/ui, Geist as the default font, i18next, TanStack Router with file based routing, and Lucide for icons. Testing is Vitest, Playwright and React Testing Library, and packaging and distribution is Electron Forge. The manifest confirms the same set at concrete versions, with the interesting detail that the shadcn CLI itself is a runtime dependency at `^4.21.0`, and that `radix-ui` is used as a single package rather than the older per-component packages.

The preferences that shape the security and the look

The project preferences section is where the template stops being a dependency list and starts making decisions for you. Context isolation is on, which is the Electron setting that keeps the renderer process away from Node internals. The React Compiler is enabled by default, which changes how React components compile and is worth knowing about if you adopt it and then debug odd re-render behaviour. The `titleBarStyle` is set to hidden, so you are expected to draw a custom title bar, and some default styles are applied in a `styles` directory under `src/`. React DevTools are installed by default. Each of these is a small thing on its own, and together they mean the application you get on the first run is not the application most Electron starters produce, which is the point of a template but also the reason to read this list before committing.

Cloning, installing and starting

The usage section is three steps, and you can also use the repository as a template on GitHub:

git clone https://github.com/LuanRoger/electron-shadcn.git

npm install

npm run start

After that, the README sends you straight to `/src/routes/index.tsx` to modify the app as you want, and it points out that a second page lives in `/src/routes/second.tsx` and can be deleted if you do not want it. The routing is file based, which is the TanStack Router convention, so adding a page means adding a file in that directory. The scripts behind the commands are Electron Forge ones, with `start` running `electron-forge start`, alongside `make`, `package` and `publish` for the build, the packaged artifact and the release.

Auto update runs through GitHub Releases

The template includes a working update path, and it has a condition you need to read before you build on it. The README warns that this feature only works in open-source repositories on GitHub, and that if you need it in a private repository you have to set up a custom update server, with a link to the Electron documentation on updating applications. The mechanism is that the app checks for updates when it opens, and if an update is available it downloads and installs it and then restarts to apply it. The implementation uses the `update-electron-app` package to check and apply updates, and for publishing it uses the Electron Forge GitHub publisher. The `publish` script creates a new release from the version in `package.json`, and it needs a `GITHUB_TOKEN` environment variable holding a personal access token with permission to create releases in the repository. A GitHub Actions workflow can do the same on a tag, though it has to be triggered manually and the release is created as a draft by default so you can review it.

Tests, linting and the shape of the repository

The test story is split by kind, which is the arrangement most projects settle on eventually. `npm test` runs `vitest run` for the unit tests, `test:unit` is the watch mode, `test:e2e` runs `playwright test`, and `test:all` runs both suites in sequence. A pre-configured GitHub Actions workflow for the Playwright tests is already in the repository. Formatting and linting run through Ultracite on top of Biome, with `check` and `fix` scripts, and there is a `bump-ui` script that runs a TypeScript file in `scripts/` to update the UI layer. The build is split across three Vite configs, `vite.main.config.mts` for the main process, `vite.preload.config.mts` and `vite.renderer.config.mts` for the preload and renderer, which is the arrangement Electron and Vite need since they are separate processes. The rest of the tree is `src/`, `scripts/`, `images/`, a `components.json` for the shadcn configuration, and a `forge.config.ts` for Electron Forge.

MIT licensed, and used by other projects

The project is licensed under the MIT License, with the licence file linked in the README. The README also keeps a section of projects built on the template, which is the most useful signal about who it fits. The listed examples are yaste, a simple cross-platform text editor that the author describes as an alternative to the native text editor of your operating system, eletric-drizzle, which pairs shadcn/ui and the Drizzle ORM with Electron, a Wordle game with interactive gameplay and a custom API for word validation, and Mehr, a local AI chat application built on Electron, React, shadcn/ui and Ollama. The range is a good description of the template's shape, from a plain text editor to an application talking to a local model. The release line is v1.3.2, v1.4.0 and v1.4.1, with the last push on 2026-10-19 and the repository not archived.

Editorial conclusion

Adopt electron-shadcn when you are starting a desktop application and want the opinionated parts settled, since it ships a fixed choice of Electron 43, Vite 8, React 19, Tailwind 4 and shadcn/ui with context isolation, a hidden title bar and a React Compiler enabled. Do not adopt it if your product needs a different renderer stack or a different packaging story, because the whole point is that these choices are already made for you. Verify first that the auto update path fits your distribution, since the README warns that it only works in open-source GitHub repositories and that a private repository needs your own update server.

Frequently asked questions

Official sources

1. License: MIT
2. LuanRoger/electron-shadcn on GitHub
3. Project website
4. README
5. Releases