# Fresh (freshframework/fresh): a Deno web framework with island hydration and no client JS by default

> Fresh is a TypeScript web framework for Deno built on Preact, with file-system routing and island-based hydration. This review covers how it works, how to scaffold a project, and where it stops being the right tool.

**freshframework/fresh** — The framework so simple, you already know it.

- Repository: https://github.com/freshframework/fresh
- Website: https://usefresh.dev
- Stars: 13,790 · Forks: 756
- Language: TypeScript
- License: MIT
- Published: 2026-09-21 · Updated: 2026-09-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/freshframework-fresh

## What Fresh solves for Deno developers

Fresh targets the gap between a static site generator and a full single-page application framework. The README describes it as a web framework built for speed, reliability, and simplicity, and the feature list is specific about how: island based client hydration, zero runtime overhead with no JS shipped to the client by default, no configuration necessary, TypeScript support out of the box, and file-system routing in the style of Next.js. The intended audience is a developer who already works in Deno and wants server-rendered pages, but still needs pockets of interactivity. Instead of shipping a bundle for the whole page, Fresh renders HTML on the server and hydrates only the components marked as islands. Everything else stays static markup. That changes the default cost model: a page with no interactive component sends no JavaScript at all. The trade-off is that any interactive behaviour has to be expressed as an island, so the framework shapes how you decompose a UI rather than just rendering whatever component tree you hand it.

## Islands, file-system routing and the Deno runtime

The architecture visible from the repository is a Deno project with a packages/ directory, a deno.json and a deno.lock at the root, and a www/ directory that holds the documentation site. The framework itself is written in TypeScript and renders with Preact, which the topics list confirms alongside deno, denofresh, fresh, javascript and preact. Routing comes from the file system, so the layout of your routes directory determines your URLs rather than a registration call. Hydration is scoped to islands: a component designated as an island gets its JavaScript sent to the browser and reattached on the client, while the rest of the tree is delivered as HTML. This is the mechanism behind the README's claim of no JS shipped by default. It also explains why the framework advertises no configuration: routing, rendering and hydration are all conventions rather than settings. The cost is that conventions are hard to bend. If your application needs a routing scheme that does not map onto files, or a rendering pipeline that mixes server and client state outside the island boundary, you are working against the grain of the framework rather than with it.

## Installing Fresh and running a first project

The README gives the install path directly. Fresh requires the latest Deno CLI, which you install separately from Deno's own site. Once Deno is available, the init script scaffolds a project. Run it from a terminal:

```bash
deno run -Ar jsr:@fresh/init
```

The -A flag grants all permissions and -r reloads the remote module, so the script can fetch what it needs. The scaffold is interactive, so expect prompts before it finishes. After it completes, the README says to navigate into the created folder, which it names fresh-project:

```bash
cd fresh-project
```

From inside the project, start the development server with the task defined in the scaffold. The README uses deno task dev:

```bash
deno task dev
```

The README states that the development server listens on http://localhost:5173, and that edits to the project source are reflected in the browser. Open that address to confirm the scaffold rendered. Deployment follows the same low-configuration line: push the project to GitHub, create a Deno Deploy project, and select the repository. The README says the result is published to a $project.$username.deno.net subdomain with no configuration necessary. Note that this deploy path is specific to Deno Deploy; the README does not describe deploying to other hosts.

## Where Fresh is the wrong choice

The strongest constraint is the runtime. Fresh is built for Deno, and the README's first instruction is to install the Deno CLI. A team standardized on Node.js cannot adopt Fresh without adopting Deno alongside it, and the repository's own tooling (deno.json, deno.lock, deno task) assumes that runtime throughout. The second constraint is the island boundary. Because hydration is scoped to islands, a UI with heavy cross-component client state does not map cleanly onto the model; you end up either widening the islands until the page is effectively a client application, or restructuring state to live on the server. The README does not discuss this boundary or give guidance on when a component should become an island. The third constraint is release cadence as a signal of maturity. The most recent release listed is 2.3.3 from 2026-04-28, and the last push to the repository was on 2026-08-02. The repository is not archived. That is a short history to reason about long-term API stability from, and the README does not document an upgrade path between major versions or a rollback procedure. If your project needs a documented deprecation policy before you commit, the README does not provide one.

## How Fresh differs from Next.js

The README itself draws the comparison on routing, describing file-system routing à la Next.js. The difference is in what ships to the browser. Next.js ships a client runtime and hydrates the page; Fresh's README states that no JS is shipped to the client by default and that hydration applies to islands. That inverts the default: in Fresh you opt components into interactivity, while in Next.js you opt out of it. The second difference is the runtime. Fresh runs on Deno and is written in TypeScript with Preact; Next.js runs on Node.js and renders React. That means the component model differs at the library level, not just the framework level, so porting a React codebase to Fresh is not a configuration change. The third difference is configuration surface. Fresh advertises no configuration necessary, and the repository reflects that with a single deno.json rather than a bundler and framework config stack. Next.js exposes a configuration file and a build pipeline. If you want to tune the build, Fresh gives you less to tune, which is the point and also the limitation.

## Maintenance, licence and what upgrading costs

Fresh is MIT licensed, so the licence permits commercial use, modification and redistribution with the copyright notice preserved. That is the licence text, not legal advice; if your organisation has specific obligations around attribution or dependency review, run it past whoever handles that. On maintenance, the facts are narrow: the repository is not archived, the last push was on 2026-08-02, and the most recent release listed is 2.3.3 from 2026-04-28. Three patch releases landed within about a day of each other in late April 2026, which suggests a stabilization burst rather than a steady drip, though the release notes available here do not say what changed in them. Upgrade cost is the weakest documented area. The README covers scaffolding, the development server, deployment to Deno Deploy, contributing, the showcase and badges, but it does not describe how to move an existing project from one Fresh version to the next, and it does not describe rollback. A deno.lock file is present at the root, so dependency versions are pinned for the framework's own development, but the README does not explain how that lock interacts with your project's dependencies. Verify that yourself before planning an upgrade.

## Conclusion

Fresh fits teams already running Deno who want server-rendered pages with Preact islands and no client bundle by default. It does not fit projects that need a Node-only ecosystem of middleware or a framework with a long release history to lean on. Before adopting, check that the Deno CLI version you have installed satisfies what the init script expects, and read the getting started guide at usefresh.dev/docs/getting-started rather than relying on the README alone. The README documents scaffolding and deployment but does not document rollback or upgrade steps between Fresh versions.

## FAQ

### How do I install Fresh?

Install the latest Deno CLI first, then run the init script with deno run -Ar jsr:@fresh/init. The README says this scaffolds a project into a folder named fresh-project, after which you start the dev server with deno task dev and open http://localhost:5173.

### Does Fresh ship JavaScript to the browser?

The README states that no JS is shipped to the client by default, and that island based client hydration is what provides interactivity. Only components treated as islands get their JavaScript sent to the browser.

### What runtime does Fresh need?

Deno. The README's getting started section begins by telling you to install the latest Deno CLI, and the repository carries deno.json, deno.lock and deno task commands. The framework is written in TypeScript and renders with Preact.

### How do I deploy a Fresh project?

The README describes pushing the project to GitHub, creating a Deno Deploy project, and selecting the repository. It states the project is then deployed to a public $project.$username.deno.net subdomain with no configuration necessary. The README does not describe deploying to other hosts.

### Is Fresh still maintained?

The repository is not archived and the last push was on 2026-08-02. The most recent release listed is 2.3.3 from 2026-04-28, so the release history available here is short.

## Sources

- [freshframework/fresh on GitHub](https://github.com/freshframework/fresh)
- [License: MIT](https://github.com/freshframework/fresh/blob/main/LICENSE)
- [Project website](https://usefresh.dev)
- [README](https://github.com/freshframework/fresh/blob/main/README.md)
- [Releases](https://github.com/freshframework/fresh/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/freshframework-fresh