Ktor/Kotlin backend provides a JSON API, centralized exception handling, and health/readiness endpoints
ktor-solidjs-template — SolidJS Starter Template
By SakuraSedaia
A full-stack starter template combining a Ktor/Kotlin backend with a SolidJS frontend, with Gradle managing builds, tests, and the frontend toolchain.
Explore the design
Compare the page layouts and mobile experience. Open any screenshot for a closer look.
Actual screenshot captured by the server browser.
All pages & views 3
Screenshots show visual appearance; interactive behavior may differ.
What stands out
A quick read of the recorded project description.
SolidJS single-page application with client-side routing, built by Vite
Gradle builds both frontend and backend and serves frontend output as Ktor static resources from the same origin
Gradle manages pinned versions of Node.js and pnpm, reducing global environment dependencies
Integrated backend tests, frontend tests, Oxlint checks, and TypeScript type check commands
Template Details
This is a reusable full-stack application starter template. The backend uses Ktor/Kotlin to provide a JSON API, and the frontend is a SolidJS single-page application with client-side routing. Gradle builds both modules and packages the frontend build output as Ktor static resources, so the frontend and API are deployed from the same origin. The repository description notes that this GitHub repository is a mirror; the main development and release process is hosted on GitLab.
The backend includes static content, Status Pages exception handling, KHealth health and readiness endpoints, Content Negotiation, and kotlinx.serialization JSON serialization. The frontend uses the Vite development server and proxies /api requests to the local Ktor instance. Gradle downloads pinned versions of Node.js and pnpm, so the combined build does not depend on global installations.
The project requires JDK 21 and provides commands for Kotlin integration tests, frontend tests, Oxlint checks, and TypeScript type checks. The template itself contains no business domain code; before use, you need to replace or adjust the frontend framework and project content according to USAGE_INSTRUCTIONS.
Is it right for your project?
Use Cases
- Starting a full-stack project that needs a Kotlin backend and a SolidJS frontend deployed from the same origin
- Teams that want Gradle to drive frontend and backend builds, tests, and dependency installation
- Projects that need health check and readiness endpoints as deployment infrastructure
- Local development with frontend hot reload and proxied access to the backend API
Suitable For
- Backend developers familiar with Kotlin and Gradle
- Developers using SolidJS or willing to replace the frontend framework according to the template instructions
- Full-stack projects that need reproducible toolchain versions
- Projects used under the MIT license with independent verification of third-party assets
Getting started & customization
Use these recorded setup notes alongside the repository instructions for your chosen version.
- 1
Requires JDK 21 and commands run from the repository root using the bundled Gradle wrapper
- 2
After running ./gradlew run, visit http://localhost:8080 to view the packaged application
- 3
For frontend hot reload, start Ktor and Vite separately: run pnpm dev under src/main/solidjs and visit http://localhost:3000
- 4
The Vite development server proxies /api requests to http://localhost:8080
- 5
This GitHub repository is a mirror; the main repository, releases, and development history are on GitLab
License & source material
Usage conditions & limitations
Free to use · keep license noticeThis entry covers the free version under the MIT license in the public repository; the free scope is the code of this version and does not mean external services or third-party assets are free.
Must comply with when using
- You may use, modify, commercialize, and distribute the code of this version for free.
- When distributing copies or substantial portions of the code, retain the original author's copyright notice and the full MIT license notice.
- The code is provided as is; warranties and limitations of liability are governed by the original license and applicable law.
Additional costs & items to verify
- Demo images, fonts, icons, and other third-party assets must be checked against their respective licenses; the code's MIT license alone is not sufficient to determine this.
- External services such as domains, hosting, databases, payments, or AI may incur separate charges.
View Original Text Basis
https://github.com/SakuraSedaia/ktor-solidjs-template/blob/main/LICENSEhttps://github.com/SakuraSedaia/ktor-solidjs-template/blob/main/.github/README.mdPermission is hereby granted, free of charge
Original License Text
Compiled by DeepSeek based on repository license and README ·2026-10-02. Results only cover the materials read; dependencies, images, fonts, and subsequent term changes are subject to their respective original texts.
Project checks & description sources
Template Information
- Source platforms
- GitHub
- Documentation and maintenance reference score
- More documented · 85 / 100
- Technologies
- SolidJS · Vite
- Website type
- Starter
How this score is calculated
Our heuristic uses license records (up to 30), a demo link (12), a preview (10), stars (15), recorded maintenance (15), description completeness (8), feature records (5) and classification data (5). It is not a code, security or performance test, or a Google score. A link does not establish tested functionality.
What to verify for this project
- Repository update recorded
- 2026-10-01
- Screenshot last checked
- 2026-10-02
A demo link is listed. Check it with your own content and viewport sizes; its presence does not confirm that forms, authentication or payments work.
The catalog identifies SolidJS as the primary stack. Check the actual dependency manifest and lockfile for versions and hosting requirements. These notes use recorded metadata, not a code audit or a deployment test.
Use a selection guide →How this description was prepared
AI-assisted description based on catalog records and repository material. Repository authors are not automatically the reviewers of this description.
Automatically checked against source and license rules; no manual editorial review.
Inspect the recorded source material
SHA-256: e58794e77fdb2a40e694194013cd2d6f8e5040f733412b4c27d0fd006e3109d9
2026-10-02T11:32:44.592Z
Source file / repository# Ktor + SolidJS Template > [!IMPORTANT] > This repository is a GitHub mirror. The primary repository, release > automation, and development history are hosted on > [GitLab](https://gitlab.com/sedaia-designs/ktor-and-solidjs-template). A reusable full-stack application starter with a Ktor/Kotlin backend and a SolidJS 2 frontend. Gradle builds both modules and packages the frontend as static resources served by Ktor. To create a project from this template or replace the frontend framework, see the [usage instructions](../USAGE_INSTRUCTIONS.md). ## Project Links - [Source repository](https://gitlab.com/sedaia-designs/ktor-and-solidjs-template) - [Work items](https://gitlab.com/sedaia-designs/ktor-and-solidjs-template/-/issues) - [Releases](https://gitlab.com/sedaia-designs/ktor-and-solidjs-template/-/releases) ## Features - Ktor Web API with JSON serialization and centralized error handling - SolidJS 2 single-page application with client-side routing - Same-origin API and frontend deployment - Vite development server with an API proxy to Ktor - Gradle-managed Node.js and pnpm versions - Integrated backend tests, frontend tests, linting, and type checking - Health and readiness endpoints The backend includes these Ktor components: | Component | Purpose | | --- | --- | | [Static Content](https://start.ktor.io/p/io.ktor/server-static-content) | Serves the built frontend | | [Status Pages](https://start.ktor.io/p/io.ktor/server-status-pages) | Handles application exceptions | | [KHealth](https://start.ktor.io/p/dev.hayden/server-khealth) | Provides health and readiness endpoints | | [Content Negotiation](https://start.ktor.io/p/io.ktor/server-content-negotiation) | Converts request and response content | | [kotlinx.serialization](https://start.ktor.io/p/io.ktor/server-kotlinx-serialization) | Serializes Kotlin objects as JSON | ## Requirements - JDK 21 Use the included Gradle wrapper for all root project commands. Gradle downloads the pinned Node.js and pnpm versions, so separate global installations are not required for the combined build. ## Quick Start Build and run the application from the repository root: ```shell ./gradlew run ``` Open <http://localhost:8080>. ## Development For frontend hot reloading, run the backend and Vite development server in separate terminals. Start Ktor from the repository root: ```shell ./gradlew run ``` Start Vite from the frontend module: ```shell cd src/main/solidjs pnpm dev ``` Open <http://localhost:3000>. Vite proxies `/api` requests to Ktor at <http://localhost:8080>. ## Common Commands Run Gradle commands from the repository root: | Command | Purpose | | --- | --- | | `./gradlew test` | Run Kotlin tests and all frontend verification checks | | `./gradlew build` | Build the frontend and Ktor application | | `./gradlew run` | Build the frontend and start Ktor | | `./gradlew pnpmInstall` | Restore frontend dependencies from the lockfile | | `./gradlew buildFrontend` | Build only the frontend | | `./gradlew checkFrontend` | Run frontend tests, linting, and type checking | Frontend commands can also be run directly from `src/main/solidjs`: | Command | Purpose | | --- | --- | | `pnpm dev` | Start the Vite development server | | `pnpm build` | Create the production frontend build | | `pnpm test --run` | Run the frontend tests once | | `pnpm lint` | Check the frontend with Oxlint | | `pnpm exec tsc --noEmit` | Check TypeScript types | ## Project Layout | Path | Purpose | | --- | --- | | `src/main/kotlin` | Ktor application, plugins, and API routes | | `src/main/resources` | Ktor and logging configuration | | `src/main/solidjs` | SolidJS frontend module | | `src/main/solidjs/dist/client` | Generated production frontend files | | `src/test/kotlin` | Ktor integration tests | During the Gradle build, the generated files from `dist/client` are copied into the Ktor resources. The packaged application therefore serves the frontend and API from the same origin. ## Documentation - [Template usage and customization](../USAGE_INSTRUCTIONS.md) - [Ktor documentation](https://ktor.io/docs/home.html) - [SolidJS 2 documentation](https://v2.solidjs.com/) - [Kotlin community Slack](https://surveys.jetbrains.com/s3/kotlin-slack-sign-up) ## License This project is available under the [MIT License](../LICENSE).
Explore similar templates
Compare previews and descriptions within the same stack and category.

tauri-start-solid
A cross-platform desktop application starter template based on Tauri and SolidJS, with TanStack Router, Nano Stores, Tailwind CSS, and Vite on the frontend.
SolidJS · Starter

solid-start-starter
A minimal opinionated SolidStart starter template with TypeScript, Prisma, tRPC, and TailwindCSS, preconfigured with pnpm, ESLint, Prettier, husky, and lint-staged. It targets Vercel deployment (requires ENABLE_VC_BUILD=1) and Prisma (requires DATABASE_URL).
SolidJS · Starter

tauri-solid-tailwind-shadcn
A cross-platform desktop application starter template combining Tauri, SolidJS, TypeScript, TailwindCSS, and Shadcn-Solid, preconfigured with Vite and hot module replacement.
SolidJS · Starter

snowpack-solid-template
A SolidJS starter template extended from Create Snowpack App, providing npm start for a development server on port 8080 with auto-reload and npm run build for a static site in build/.
SolidJS · Starter

react-starter-kit
A full-stack SaaS monorepo starter built on Vite and React, with Bun, TypeScript, tRPC, Drizzle ORM, Better Auth, Stripe, and Cloudflare Workers. It includes email OTP, passkey, Google OAuth, organizations, subscription billing, Drizzle migrations, seed scripts, and Terraform infrastructure.
Vite · SaaS

vitesse
Vitesse is an opinionated Vite + Vue 3 starter template maintained by antfu-collective, offering file-based routing, component and API auto-import, Pinia, UnoCSS, PWA, i18n, Markdown, vite-ssg, TypeScript, Vitest, and Cypress.
Vue · Starter
