SolidJSViteStarter

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.

3 previews
Desktop homepage1 / 3
Desktop captureTop of page

Actual screenshot captured by the server browser.

All pages & views 3

Screenshots show visual appearance; interactive behavior may differ.

Recorded 2026-10-02View source

What stands out

A quick read of the recorded project description.

01

Ktor/Kotlin backend provides a JSON API, centralized exception handling, and health/readiness endpoints

02

SolidJS single-page application with client-side routing, built by Vite

03

Gradle builds both frontend and backend and serves frontend output as Ktor static resources from the same origin

04

Gradle manages pinned versions of Node.js and pnpm, reducing global environment dependencies

05

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.

SolidJSViteLauncher

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. 1

    Requires JDK 21 and commands run from the repository root using the bundled Gradle wrapper

  2. 2

    After running ./gradlew run, visit http://localhost:8080 to view the packaged application

  3. 3

    For frontend hot reload, start Ktor and Vite separately: run pnpm dev under src/main/solidjs and visit http://localhost:3000

  4. 4

    The Vite development server proxies /api requests to http://localhost:8080

  5. 5

    This GitHub repository is a mirror; the main repository, releases, and development history are on GitLab

Read repository instructions

License & source material

Usage conditions & limitations

Free to use · keep license notice

This 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

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).
Report a correction

Explore similar templates

Compare previews and descriptions within the same stack and category.