Val Town Release Notes

Code example

Using the std/sqlite val to access the val database:

import sqlite from "https://esm.town/v/std/sqlite/main.ts";
await sqlite.execute('CREATE TABLE IF NOT EXISTS "docs" (contents TEXT)');
await sqlite.execute('INSERT INTO docs (contents) VALUES ("Hello, world!")');

Demo

With the built-in SQLite browser you can:

• Add and rename columns
• Delete rows
• Get the schema of any table
• Run queries
• Export tables as CSV
• Dump the database as SQL

History

In 2023 we launched SQLite for every Val Town user, powered by our friends at Turso. Vals could use the database with zero configuration and total control. A lot of the most interesting vals are built on this - my Bluesky ThinkUp Tribute val uses SQLite to store people's social media bios, and devstats uses the database to track statistics about our repository.

But because databases were scoped to users and organizations, they contained intermixed data: it's impossible to tell a priori which data came from which val. Scoped databases fix that problem, eliminating conflicts between different vals and making it easy to just browse val-specific data.

Security

We've designed scoped databases to be more secure, too: vals can only access their own scoped database, and can't reach across to access data from other vals. This makes it a lot safer to work on SQLite databases too, because your schema changes can't affect any other vals.

Under the hood, we've added project-scoped API tokens to make this work: each val automatically gets a temporary API token as the VAL_TOWN_API_KEY environment variable. That API token has always belonged to a user, but now it belongs to a val as well, which gives it specific val superpowers.

Existing databases will stick around

We're supporting both val-scoped and user-scoped databases for the long term: there are uses to both, and there's no reason to force everyone into a gnarly upgrade path. But val scoped databases are definitely recommended for new projects: they make a lot of things easier, and come with a powerful UI.

Thanks Turso for the continued collaboration!

We've provisioned thousands of databases and this will add even more - but it's possible because Turso runs SQLite in the cloud. This feature really relies on some tricks from Turso too, like forking databases by seeding from point-in-time backups.

We’re hiring!

Join our team and help build the future of programming.

Original source Report a problem

Townie's back!

Townie's back! In its 5th version, Townie, our AI agent, lives alongside your code editor, powered by the Claude 4.5 family and our carefully crafted tools.
Townie is like Claude Code, but in the browser, optimized for Val Town's simple and instant runtime.
Here we ask Townie to scaffold this very blog post:

Like every edit in Val Town, Townie's changes are instantly deployed live on the internet at a URL (or a branch-preview-URL) in 100ms.

What can Townie do?

Townie can take almost any action that you as a user can take:

• List, search, & create vals
• Read, write, & run files
• View history, create & switch branches, revert versions
• Query your SQLite databases & Blob storage
• Read & write environment variables
• Read logs
• Read & configure cron jobs

Because Townie has so much context, you can ask it to one-shot whole features or even full-stack apps. Or remix one of our templates. Townie gets the same tight feedback loop that Val Town users get:

1. Edit code
2. Automatically deployed live in 100ms
3. Run the code
4. View the output
5. Read the logs
6. Keep iterating until done

You can rely on version history and branching to move fast without breaking things, along with Townie's chat history to pick up where you left off.

Modes

We're using the latest models in the Claude 4.5 family — Haiku, Sonnet, and Opus — with three modes:

1. Normal: Townie asks you to approve before writes
2. Plan: Townie as your read-only thinking partner
3. Allow all edits: Townie YOLOs changes to your vals

System prompt

Townie knows Val Town inside and out. Our system prompt is public (still), and it doubles as a great "101 intro to Val Town."

Keyboard shortcuts & slash commands

As a power user, you can open Townie with ⌘J and use slash commands:

• /cost Show estimated cost and usage
• /context Show context window usage
• /compact Summarize older messages to save context
• /clear Start a new chat

Townie is writing ~50% of my code

Before Townie v5, we didn't think we needed an in-browser AI agent. We wanted to thoughtfully craft a good MCP server and let you the developer stay where you are (in your favorite AI coding tool). And we did. And you can!
But MCP clients just aren't good enough yet, so that experience often falls short. Our customers asked for a good in-browser AI agent. Honestly, we as users of our product wanted this too. And it's pretty great! I use Townie v5 a lot now. Sometimes I use it for vibe coding (for prototypes or simple things), and other times I keep it on a tight leash (for stuff I care about).
It's fun and productive – give it a try!

Try Townie

Townie is available in public beta for Pro and Teams customers, so you can try it for $10/mo.

Thanks to Pete for helping me write this and crafting the lovely Townie doodle at the top.

Original source Report a problem

On Val Town and MCP server

On Val Town, you deploy JavaScript in 100ms. Now with the Val Town MCP server, you can do that from Claude, ChatGPT, Cursor, VSCode, or wherever you do your AI coding.

If you've been following my tweets recently – "I've gotta rant about LLMs, MCP, and tool-calling for a second", "MCP is mostly nonsense", "MCP is overhyped" – you might be surprised by this announcement. Well, how did you think I got those salty takes except by building an MCP server?

Yes, I think MCP is dubious as a protocol. But for now, MCP is the right way for Val Town to meet developers where they are. In Cursor or Claude Code or Zed or wherever. For example, here we use Claude Code to make a blog. Every edit is immediately live and deployed on Val Town.

We have guides for some of the popular LLMs:

• Claude Code
• ChatGPT
• Claude Web/Desktop

But the Val Town MCP server should work with any MCP client. If you'd like a hand with setup, ask in our discord server or send us an email.

Why MCP

MCP is not perfect (again, see tweets), but it has a few things going for it:

• Cheaper – Don't pay us for credits. Pay your inference provider directly.
• Better – Use whatever state-of-the-art LLM you want. We at Val Town don't have to fast-follow it.
• Val Town everywhere – Get the best parts of Val Town – instant deployments, built-in SQLite, etc – in your favorite LLM coding tool.

MCP also allows us to ship faster. Traditional APIs require careful versioning to prevent breaking changes, but an MCP server can change continuously because LLMs read the spec and run inference at runtime.

Fast feedback loops

There's a common thread running through every feature we build – AI or otherwise: enabling fast feedback loops.

Creators need an immediate connection to what they're creating.
If you make a change, you need to see the effect of that immediately.

• Bret Victor, Inventing on Principle

When you – or your LLM – make an edit on Val Town, your code is deployed in 100ms. This allows you to have insanely fast feedback loops in your production environment. No need to wait a minute or two to see how it'll actually look when deployed. Every change is immediately live, at a public URL.

Val Town isn't an AI company – we're a developer tools company – but this always-deployed model works quite well with LLMs. Just give your favorite LLM a branch, and the code it writes will be alive and sharable by default.

Bring Val Town MCP to your favorite LLM, and let us know what you think.

Original source Report a problem

Introducing vt, the CLI for Val Town

Introducing vt, the CLI for Val Town that lets you use your favorite editors and local tools. Now you can use VS Code, Claude Code, Codex and more with our super-fast feedback loop, deploying software instantly as you develop it.

To get vt, install Deno, then run

deno install -grAf jsr:@valtown/vt

With vt, you can:

• Use vt watch to watch a folder for changes, pushing updates and redeploying instantly as you save
• Remix or create brand-new Val Town projects directly from your command line
• Livestream logs from your Val directly to your terminal
• Manage branches, switching between separate deployments or prod & dev branches of a project

We designed vt to work much like git, so vt branch and vt checkout -b work just like you'd expect. But the real magic is in the vt watch command: vt can resolve deltas between Val Town and a local folder of TypeScript and text files, automatically detecting file changes like renames and modifications. As you edit in VS Code, neovim, or your favorite editor, every time you save the changes go live. Or, if you don't want to live on the edge, you can use vt push to explicitly push new changes.

Bring your own editor - and LLMs!

vt works perfectly with your favorite LLM tools: it can even initialize a AGENTS.md file that contains all of the context necessary to write code for the Val Town platform.

People are already using vt to build cool projects, like Geoffrey Litt's Stevens project, a really cool AI personal assistant telegram bot, built locally with cursor and vt. We built Val Town's new Val search on Val Town itself, with Claude Code and vt.

Use the companion browser extension

vt also has a companion browser extension which pairs with vt watch to automatically reload the tab as you edit your Val.

It's available for Chrome or Firefox.

If you have vt watch running, it should "just work"! The companion communicates with vt's watcher over a local WebSocket connection.

We want feedback!

vt is a big leap forward in the local development experience for Val Town. But we're always looking to improve and polish the experience. If you have any feedback we'd love to hear it. You can join our Discord server here, and contribute ideas, PRs, or issues to the val-town/vt GitHub repo.

Original source Report a problem

Introduction

Val Town makes it easy to ship TypeScript automations and applications to the internet via an integrated web editor experience. We strive to offer a magical tight feedback loop, with 100ms deploys on save.

That online editor experience should be great: we should support high-quality highlighting, autocompletion, information for when you hover over bits of code. But unfortunately it hasn't been so: our previous editor has been buggy and slow to give useful TypeScript feedback.

But now, we've rewritten our editor's TypeScript integration from scratch. It's available to all Val Town users, is fast and accurate, and the code is open source.

Our old system: running TypeScript in a Web Worker

Our previous language integration was entirely client-side. We ran a TypeScript Language Service Host in a Web Worker, to isolate it from the top frame's thread, and communicated between the Web Worker and top frame using Comlink.

The system looked like this:

We bundled it into codemirror-ts, a CodeMirror extension, and Deno-ATA, an incomplete implementation of Deno's import resolution logic grafted onto TypeScript's capabilities.

This solution worked great in the simplest cases, but stumbled when importing certain NPM packages, and required more and more workarounds. The main two issues we were facing were these:

1) TypeScript isn't written for Deno

At Val Town, we run Deno, a modern JavaScript runtime that differs from standard TypeScript. Deno supports URL imports, provides server-side APIs through the Deno global (like environment variables), and introduces its own quirks. Sometimes we’ve been able to work around these differences. For example, we could use Deno type definitions. But in other cases, like handling URL imports, it requires us to interpret files differently. Deno is distinct enough that it ships its own language server, built in Rust and wrapping tsserver.

2) NPM modules can be gigantic and installing dependencies is no joke

Huge import trees for NPM modules are nothing new, but at least when you're installing NPM modules locally, you have the brilliant minds of the package manager implementers to do module resolution: to install the minimal number of packages by comparing semver ranges. We didn't have that luxury, and often referencing an NPM module would trigger an avalanche of HTTP requests and bytes downloaded, which would overload the Web Worker and make the editor's language tools unresponsive.

Bringing DenoLS to Val Town

So, we redesigned our editor's TypeScript handling. Instead of running TSserver in a Web Worker, we now run the official Deno Language Server remotely in cloud containers.

We no longer suffer writing our own workarounds to the mismatch between TypeScript and Deno, because the Deno project's Rust code that wraps around a TypeScript instance solves all those problems. Your browser doesn't struggle to download huge NPM dependency trees because a beefy server does that for you, from a faster connection.

Now, when you visit our editor, we launch a containerized server that exposes a WebSocket and speaks the LSP protocol. The architecture was partially inspired by Mahmud Ridwan's great writeup of connecting CodeMirror & an LSP, with the main difference being that we directly map stdio to the WebSocket rather than serializing messages, because vscode-jsonrpc can do that for us!

Our open source implementation

To tweak the language server for our unique purpose, while keeping the Codemirror extensions LSP-generic, we also took inspiration from the official VS Code LSP client library, which we couldn't use directly because of its reliance on VS Code globals. Their client provides a way to use middleware and URI transforms so that you can easily tweak the language server at the client level when writing VS Code plugins. Transforming URIs makes it easy to spawn the language server from a temp directory but map file paths as if they were relative to the root, and middleware modify the language server for our unique use case, like automatically downloading dependencies when the server sends the client a red squiggle saying a package isn't installed. We built a similar style system as a Language Server proxy server library. It acts as a language server of its own, but can arbitrarily modify messages passing through it.

To actually host the LSP as a WebSocket server, there are various subtleties that were important for our use case. We want to keep connections persisted even when the editor leaves, and allow multiple clients to connect to the same language server instance (to support multi tab, or even multi-browser/device editing). Our implementation uses a stream WebSocket wrapper and pipes stdio directly, and manages multicasting connections so many clients can talk to the same process at once.

Bringing it to the Browser

Once we had a language server server in place, we needed a client. This will be querying for hover information on symbol hovers, displaying red squiggles, and all of the rest of the language-specific tooling. The LSP specification is quite sprawling – there are many fun features to support, like code actions (buttons such as "infer return type") and method suggestions (that pop up as you call functions). Meanwhile we need the client to keep documents synced with the language server, and send document update events.

There are some existing CodeMirror language server client implementations, which we pulled from when building our own. We wrote our own so that we could support more arbitrary transports, in our case WebSockets with message chunking, external renderers for language server UIs (like to be able to use libraries like React, highlight.js, or remark), and take external callback inputs (so that you can implement things like going to definition on an external document).

Shipping on Cloudflare Containers

For deploying our language servers, it was important that we kept user workloads isolated because code is private. Even though we are running language server processes in temporary directories, you can still infer types of libraries in other directories by importing upwards "../../", and possibly even hop to their definition.

We also wanted servers to live for as long as the user's session. Someone might be editing code for two hours, so a solution like traditional AWS Lambda would be a tough fit. Finally, we wanted to restrict users to using a limited amount of language server resources at a time.

Initially, fly seemed like a great option. We could spin up containers on the fly (🥁) and shut them down when not needed. The issues we saw with fly were that we'd need to manually manage the lifecycles of our containers, routing individual users to unique containers, and make sure containers shut down after some amount of time not sending heartbeats from the client.

When Cloudflare announced Cloudflare containers, they immediately seemed like a perfect choice. Cloudflare containers fit within their worker/durable object ecosystem and are tenants of durable objects. This means that they are routable by an arbitrary ID, and that the durable object layer (a persistent, serverless, JavaScript class instance) can internally manage container lifecycles. In our case, we're routing users to a durable object with the ID that is their literal user ID, and then using their container library to shut containers down after inactivity.

This means that we didn't actually need to implement any stateful routing layer ourselves. When you want to connect to a Val Town language server, you simply hit our Cloudflare worker with a signed cookie containing your user ID, which routes you directly to a already-running, or brand-new durable object/container that boots your LSP. In the future, it will also be easy to hook into Cloudflare's built in worker sqlite db to internally manage utilization too.

All together, the architecture ends up looking like this:

A server replaced the WebWorker, and instead of communicating by postMessage (via Comlink, to a WebWorker), we now use a WebSocket. But the biggest win here is using the Deno Language Server and an isolated server for running language tooling: this lets us piggy-back on the stock implementation of module resolution and keep those huge NPM dependency trees out of the browser's responsibilities.

Try it out

The easiest way to see this all in action is to sign up for Val Town and write some code! While we'll continue striving for perfection, it's nice to know that we've gotten a lot closer to it this summer.

Out is the editor that was slow, buggy, and required a lot of custom workarounds. Now every user has the full, luxurious Deno language server experience.

Now that our editor is in production, it will only continue to improve. We have plans to add more Val Town specific language server functionality, like suggesting Val Town standard library function imports, giving useful diagnostics about aspects of Deno that behave differently on our platform, and adding more language server features.

We've also open-sourced everything you need to ship your own cloud container WebSocket language server as vtlsp. This repo includes the client, server, and proxy, which you can see in the demo below.

Original source Report a problem

This post is for our fellow engineers & founders doing GTM / sales.

I used to think doing enrichment was for big companies with massive outbound sales functions. Before launching Val Town for Teams (coming this week!), we set a goal: find 10 pre‑sales customers. All of a sudden, I was spending all my time looking for teams who could be the right fit. Our best channel was obviously new users signing up for Val Town. However, scrolling through emails and hoping we recognize someone quickly became unsustainable. (And really it only works for celebrities anyways.)

Clearbit vs Clay vs Val Town

Clearbit used to be the obvious answer, but post‑HubSpot acquisition, it's no longer an option for small new customers. Clay is great, but we wanted to use it like an API so anyone on our team could use it programatically, without Clay knowledge or set-up. We asked on X, the CEO explained how we could do it.

Introducing: Clay API Proxy

We turned Clay into an API / SDK on Val Town via our Clay API Proxy. The hard part was that Clay enrichments are triggered by one webhook, but you get the results from another webhook. We wanted the developer experience to be a single request that gets back the enriched data as the response. Here's how we built it:

1. Your val imports and calls our clay() "sdk" function with an email or GitHub username
2. Our proxy authenticates you as a Val Town user
3. We generate a request id, and forward the payload to Clay with that id
4. Clay enriches, and POSTs the result back using the id. We save the result to SQLite.
5. While your original request is still open, we poll sqlite for it.
6. When it returns, we give you the JSON back in the normal request/response pattern.

Enriching emails with Clay is now as simple as:

import { clay } from "https://esm.town/v/charmaine/clay-proxy/sdk.ts";
const result = await clay({ email: "[email protected]", source: "user_signup", });
console.log(result);

Which returns:

{
 "email": "[email protected]",
 "person": "Steve Krouse",
 "linkedin": "https://www.linkedin.com/in/stevekrouse",
 "company": "Val Town",
 "funding": "Seed round",
 "totalFunding": "$7 million",
 "employeeCount": "6"
}

How this helps

User enrichment is a big part of how we successfully found our first 10 pre-sales customers. Our users are no longer a long list of anonymous emails. We are able to more efficiently spend our time interacting with our ICP (Ideal Customer Profile) as soon as they sign up, instead of combing through endless dashboards in search of a unicorn.

• We see new users joining in real-time, with their enriched profiles
• Anyone can start a thread, tag the right person, or notify everyone else that they've already reached out. For example:
• Warm intros were easy to track
• The team then starts building intuition about: how many new users joined, are we attracting ICP, who owns follow‑ups etc.

Then what?

Once you have this data on Val Town, there's lots you can do. Here are some templates:

• Send new user enrichments to Slack
• Enrich yours' or your competitors' GitHub repo stargazers
• For fellow devtool companies, we reach out with an auto‑generated Val that runs their SDK so the first touch includes a working demo. This got some great responses!
• Get Townie to build custom outbound demos etc. based on their profile. (Patrick Spychalski has a great example post with a similar workflow.)

We've been loving these experiments, and would love to help more engineers scale the traditional GTM function.

Pricing

Clay credits aren't free, so we can't let just anyone use our proxy. We've allowlisted a couple of friends who we know are good for it, and can bill them later. If you wanted to get started, shoot me an email at [email protected] and I'll personally help you get set up. We also have a self-hosted alternative, if you'd like to create an API for your own Clay account.

Original source Report a problem

Credits payment update

Today, we are introducing a new credits payment system for Townie, our AI coding assistant. Townie is now pay-per-use. Here's the upside:

• You can use Townie as much as you want – no limits
• Townie is now priced independently from Val Town Pro, which makes it cheaper for casual Townie users
• Townie becomes sustainable
• We at Val Town get a clearer signal about how much to invest in making Townie better

How credits work

We charge a 50% markup on top of raw LLM costs. If you use $10 in Townie credits, Anthropic will get $6.66 and we'll get $3.33. We think this is fair, sustainable, and transparent. We don't want to be in the business of having murky limits, obfuscated credits, or unsustainable margins.

When you pay for Townie, you're telling us in the clearest way possible to continue to invest in Townie. If you don't think Townie is worth the cost, there are many wonderful AI coding alternatives that you can use with the new Val Town CLI. We want you to choose Townie on its merits, not because it's subsidized.

Start coding with Townie

We think Townie is one of the best coding assistants out there. It uses agentic tool-calling, powered by Claude 4 Sonnet, to read and write your code. It can even make test HTTP calls and inspect logs & traces to see how things are working, and keep iterating from there. Paired with Val Town's instant (100ms) full-stack deploys, Townie is one of the fastest ways to create a deployed app.

We hope you give it a shot, and are very eager to hear what you think.
Start coding with Townie here: val.town/townie
ps - Townie is 100% open-source & is hosted on Val Town

Original source Report a problem

Val Town has gotten a lot more powerful.
Vals now support multiple files, folders, and branches. You can edit vals locally with your favorite editor via the vt CLI. Townie, our AI coding assistant, uses Claude 4 Sonnet to agentically read and write your vals. We've been supporting companies using Val Town to automate workflows and build internal tools.
Our roadmap is packed with the powerful features you've been requesting: Team Accounts, SOC2, Logs & Traces API, OAuth, and much more.
As always, we save the best part of the newsletter for last: a collection of the best new vals from all of you in the community 🤩

🗂️ Multi-file Vals

We rebuilt vals from the ground-up to support multiple files and folders. Vals are now like GitHub repos – including branches and pull requests – but the code is instantly deployed, and scales as hosted web services. We rebuilt Townie, Search, and even this very blog you're reading right now as vals.

As show in this video above, vals now support:

• Multiple files & folders
• Branches, three-way merges, and pull requests
• Custom subdomains & email addresses

🦾 New Townie

We rebuilt Townie from the ground-up around multi-file vals. It uses agentic tool-calling, powered by Claude 4 Sonnet, to read and write your code. It can even make test HTTP calls to see how things are working, and keep iterating from there.

Townie is available only for Val Town Pro users during a limited free preview. We are adding the ability to purchase credits.

Because Townie was built 100% open-source and in userspace, you can read the code, system prompts, and even remix & run it in your account. Pull requests welcome.

＞ Local development
One of the biggest feature request for Val Town has always been to edit vals with your favorite editor. Now you can with the vt CLI.

The vt watch command brings the classic Val Town deploy-on-every-save experience to your favorite IDE. (Especially with the browser extension that automatically reloads your browser tab.) However, that doesn't mean you're deploying to production on every save. As shown in the video above, Val Town means you're always developing directly in your production environment, but you choose when to deploy directly on main or in a branch preview that you can merge in when ready.

Val Town for Teams

If you think Val Town is useful in your personal life, wait till you bring it to work! Our customers have saved hundreds of hours building custom tools like:

• GitHub x Slack Automations: Auto-assign PRs, enforce labels, streamline PR approvals, and surface GitHub issues in Slack.
• Hubspot Leads Deep Research: Generate AI deep research-powered reports on new HubSpot leads. Optionally convert them into audio feeds for on-the-go listening.
• Discord → Linear Tickets: React to messages with a designated emoji to instantly create a Linear ticket, with full context.
• Changelog Generator: Auto-generate changelogs from GitHub commits and share them in Discord for review before publishing.

We'd love to help you too! Our Val Town for Teams plan includes private VIP support on Slack Connect, hands-on help building custom workflows and onboarding your team, and higher limits across the board.

💌 Email [email protected] to save your team hours every week.

New Search

We rebuilt Val Town Search for the multi-file vals. It's much faster and gives exact matches. (It runs on Val Town SQLite, and uses like.) It searches across public val source code, usernames, and our docs.

Search was built 100% open-source & in userspace. With one-click, you can remix it to your account: it'll start reading from the public val firehose API, and index all public val code into your Val Town SQLite. If you want to make an improvement to search, or build something on top of that index, please do! The power of userspace 💪

Town Hall

We held our very first Val Town Hall!

We got a chance to share what we're building at Val Town, and see 9 lovely demos from the community. Everybody really pulled together to make it an action-packed hour. If you're curious to know what's going on in the town, this is a must-watch.

Val Town Hall #2

We scheduled the next Val Town Hall for June 25th, 12pm ET.
Register here to participate or demo.

Roadmap

• Logs & Traces API (to power vt tail & Townie reading logs)
• UI improvements branch & pull request flows
• UI improvements to Logs
• Deno LSP to dramatically improve the browser editing experience
• Townie credits & other improvements
• UI improvements to val version history
• Team Accounts
• "Login with Val Town" OAuth
• SOC2
• Ability to lock/protect a main branch
• Comments on vals (again, but better, ie on lines)
• Comments on pull requests
• Improve the discoverability of vals
• Binary file support in vals
• Infinite scale vals with usage-based pricing
• WebSocket vals
• UI & keyboard affordances to help you import from Val Town, npm, jsr

🌟 Community Vals

• Geoffrey Litt's Stevens went viral on HackerNews. It's a personal AI Assistant, you can read more about how he built it on his blog.
• Brad Noble made Val Town for Notion, a great demo accompanied by a post about using Val Town to unlock Notion’s full potential, and vice versa.
• Fiberplane made OpenTelemetryCollector, which receive traces and store it in SQLite.
• bgschiller made personalShopper, which turns any grocery list into a Kroger cart full of groceries.
• Moe made MiniAppStarter, a Hono + React + Tailwind + Farcaster Mini App Starter Project. This has taken off in the Farcaster community and we've been seeing lots of new mini apps! You can find other Farcaster starters directly on moe's profile.
• Smirfolio made petitPrince, a child-friendly article summarizer.
• tmcw made timeline, an online card game for 2+ players: draw historical‑event cards and race to slot them into the correct timeline.
• Wolf made FileDumpThing so you can easily share files and text snippets by pasting or uploading them and getting a URL in return. This is very handy for dropping gifs into val READMEs.
• Michael Schultz made eink-frame for information screens designed to be shown on an e-ink display.
• Wilhelm made ProtoRuns, which lets you track and store your physical runs on ATProto.
• Loading made url-project, a simple URL shortener application built on Val Town.
• c15r made ProtoShare, a secure backend system for iOS share sheet shortcuts.
• Cam Pak made voicemessages, a web app for recording, transcribing, and sharing voice notes with expiration controls.
• Salon made mandate, a val that helps you set up AI agents through a registry and workflow definitions.
• Wolf made Electric, a lightweight static site hosting system built on Hono RPC and Val Town blob store, with a simple CLI.
• supagroova made LiveStormMCP, a val that is hosting a Livestorm MCP server.
• Malcolm Ocean made FlexCal, a flexible Google Calendar alternative interface that syncs 2 way with Google Calendar via OAuth.
• Max made esm, a fast content-type friendly proxy for esm.town.
• Alex Wein made gordwame, a word game.
• nucky made book-lookup-notion, which uses the Google Book API to look up bibliographic metadata elements. The val thumnail is a great gif.
• chadparker made endpoints for interacting with Notion DB.
• artivilla made fren, an app for browsing, searching, and copying AI prompts, similar to ray.so/prompts/browser.
• probablycorey (who started Atom and Electron at GitHub!) made mini-remix, which lets you write server side and client side react code in the same file and render it to a val.
• ije made mono-jsx, mono-jsx just works on Val Town!
• boucher made vt-discord, which stores your chats and shared links on a private server, and lets Claude AI search and analyze them.
• dcm31 made logoWorkshopOpenMoji, an SDK to generate logos directly in code.
• Wolf made NPLLM, a clone of the npm website with search functionality, package detail pages, and the ability to download npm packages as tar files.
• dcm31 made demoCamera, a floating webcam component that you can easily add to any val.
• prashamtrivedi made promptfixer, a prompt fixing service with form and email processing.
• elouan made oceaniverse, a pondiverse store.
• bradley made litebrite, a little web‑app version of the classic Lite‑Brite toy.
• Steve Krouse made live-reload, middleware for live-reloading HTTP vals during development. (We use it to edit this blog!)
• gwoods22 made cp24-digest, a val that manages CP24 email alerts by recieving them, storing them in a blob, and displaying them here.
• Nico Baier made thirdTimer, a web app implementing the "Third Time" productivity method. neverstew remixed it with visual displays.
• pomdtr made tinyfeed, which generate a static HTML page from a collection of feeds.
• thirdsouth made Mercury, which connects Mercury's Bank API to Slack so you can check account balance, view recent transactions, get notifications etc directly in Slack.
• cmknz made maine-bills-tax, which summarizes all of the current pending bills that could impact taxes in the State of Maine.
• kamalnrf made MailGoat, which automatically organizes your emails with custom labels.
• Wolf made instagramScraping, which extracts image and caption data from Instagram posts.
• colingourlay made supernote-crosswords, which uploads daily crosswords to your Supernote.
• humbl made figma-variables-manager, a Figma plugin that syncs variables from external sources like Notion and Coda.
• dcm31 made build.moi, a social showcase for your Val Town vals, like TikTok but Val Town! (YouTube demo)
• yakuzadave made notionWidgets, a way to be able to host your own Notion Widgets using Val Town.
• jpchip made GlobalEntryAppointmentChecker, which emails you when global entry appointments are available.
• nucky made notion-2-bluesky, which lets you auto-schedule Bluesky posts from a Notion DB.
• Llad made Gardenon, to help map your garden and track information about each plant.
• Steve Krouse made profile-pics, a Val Town Profile Pic Proxy.
• stu43005 made hololiveAnniversaryIcs, for tracking anniversary dates for Hololive (a virtual YouTuber agency).
• jamiedubs made twitterCompetitorMonitoring to track tweets mentioning competitor URLs and visualizes the data in charts.
• We at Val Town made door for Val Town office guests to open the door through their phone, like this!
• Joey Hiller made ValTown-Package-Tracker to track a package of sensors he was sending from Oakland to us in Downtown Brooklyn!
• dinavinter made slack, a Slack bot that uses OpenAI to generate responses.
• prashamtrivedi made hn-remote-ts-genai-jobs, to track Hacker News' Who's Hiring filter for remote TypeScript + GenAI-related jobs.
• dcm31 made rotrank, an ELO ranking system for popular Italian Brainrot characters.
• tmcw made bluesky-thinkup-tribute, so you can know when people you follow update their descriptions on Bluesky.
• Alex Brinsmead made autonomous-val, a demo on how to build autonomous agents on Val Town that can be triggered by API calls, cron jobs, etc.
• pomdtr made extract-feeds to extract RSS feeds from an HTML page.
• curtcox made wwtdotcom, a proxy for wwt.com that rewrites all links to stay within the proxy and injects a help widget on every page.
• ashryanio made halpk, which fetches the RSS feed from Astoria Tech's Subcurrent blog and displays a random blog post each time the page is loaded. He also made subcurrentShuffle with Townie in 15 minutes at that same meetup!
• Cam Pak made groq-api, a simple API using the AI SDK and Groq.
• mgmarlow made aposd-red-flags, a simple flashcard app to help learn about common software design red flags from the book A Philosophy of Software Design by John Ousterhout.
• JJG made blockbench-plugin, which fetches JavaScript or TypeScript files from GitHub repositories or Gists and serves them with the proper content type headers.
• Steve Krouse made luciaMagicLinkStarter to roll-your-own auth & magic link login using Lucia.
• Max made sqlitelogs, a logging system that stores logs in SQLite with a web interface and search functionality.
• orjpap made a blog analytics system using Val Town's SQLite to track visitors and page views.
• Payton made Privy Pay, a tap to pay experience with Farcaster mini apps using NFC technology.
• yawnxyz made andp, a demo of embedding Observable in Val Town.
• neverstew made voweltown, an interactive website to explore vowels across different languages.

Original source Report a problem

Overview

Today, we’re unifying our two primitives — vals and projects — into a single primitive: the val, with the best features of both.
Historically, vals have been simple and lightweight, but limited to a single file. This upgrade will preserve the elegant spirit of our platform while supporting more complex code and collaborative workflows. This upgrade will help you create bigger things on Val Town – APIs, internal tools, fullstack apps, blogs (like this one), and much more – without sacrificing the simplicity you've always loved about vals.
Legacy vals will temporarily become projects during this migration. Post-migration, the concept of projects will disappear entirely — leaving only upgraded vals. In short: legacy vals → projects → vals.

Timeline

For most users, no upgrade action is required. We’ll auto-migrate your vals next week. All existing HTTP endpoints, crons, email handlers, and custom domains will be preserved.
For those with mission-critical vals or who use our API to edit or create vals, you can start upgrading your legacy vals today and integrating with our updated API.

• April 23, 2025 – Announcement of changes & API deprecations.
• April 30, 2025 – All remaining legacy vals auto-upgraded. Deprecated API routes become read-only.
• May 1, 2025 – The term projects will no longer exist — everything will simply be a val.
  If you need more time, please contact us at [email protected] and we'll work with you.

Upgrading

We will upgrade all remaining legacy vals on April 30, 2025.
You can proactively upgrade by:

• Going to the Settings of any legacy val.
• Clicking Upgrade.
  See more details in our docs.

API Changes

Today, we're introducing the following API routes:

GET    /v2/vals
POST   /v2/vals
GET    /v2/vals/{val_id} 
DELETE /v2/vals/{val_id}
GET    /v2/vals/{val_id}/branches/{branch_id}
DELETE /v2/vals/{val_id}/branches/{branch_id}
GET    /v2/vals/{val_id}/branches
POST   /v2/vals/{val_id}/branches
GET    /v2/vals/{val_id}/files
POST   /v2/vals/{val_id}/files
DELETE /v2/vals/{val_id}/files
PUT    /v2/vals/{val_id}/files
GET    /v2/vals/{val_id}/files/content
GET    /v2/alias/vals/{username}/{val_name}
GET    /v2/me/vals

Note: During this transition, {val_id} is your project ID. You can grab it by clicking Copy > Copy project ID on any new val.
We are deprecating these routes:

• /v1/vals/*
• /v1/projects/*
  GET /v1/alias/{username}/{val_name}
  GET /v1/alias/projects/{username}/{project_name}
  GET /v1/me/comments
  GET /v1/me/references
  GET /v1/me/likes
  GET /v1/me/projects
  GET /v1/users/{user_id}/vals
  View our updated API reference here.
  All v1/vals API routes become read-only on April 30, 2025. If you rely on writing to those routes, please upgrade to our new v2/vals API. All deprecated API routes will continue serving historical legacy val data.

SDK changes

We've also released a new major version of the Val Town SDK, v1.0.0, using these new endpoints. The deprecated routes above are not accessible in this new version of the SDK.
Unpinned SDK imports will automatically pull the latest version upon your next edit / save. At that point, your SDK calls will temporarily break until you upgrade. To upgrade, update every mention of projects → vals, projectName → valName.

What's next

1. Upgrade your mission-critical vals early.
2. Update your Val Town API & SDK usage to /v2 routes.
3. All remaining legacy vals migrate on April 30, 2025.
4. Migration completes on May 1, 2025.
   We're committed to making this transition smooth for you — reach out anytime via email or Discord if you need assistance. We appreciate your help and patience through this migration.

Original source Report a problem

Val Town Projects have landed. If you like vals, you are going to love Projects. We also shipped Highlight to Edit with AI, redesigned Logs, enabled public HTTP endpoints with private code, and much more.

This month, we’re fixing many of the frictions y’all are reporting with Projects. Most excitingly, we’re building a CLI to let you edit your Val Town Projects locally, so you can use your favorite text editor and AI tools, like Cursor and Windsurf.

As always, the highlight of this newsletter is the community vals. We’re so inspired by the creativity of the things you’re building. Keep it up!

Val Town Projects
Val Town Projects unlock a whole new level of complexity for what you can build in Val Town.

In this video, I demo a Val Town Project that lets you download the source of any Val Town Project as a zip file. I fork the project, run it on my account, edit it to list a smaller, random number of projects, and send a pull request – all in 60 seconds.

Val Town Projects are groups of vals versioned collectively and deployed on our serverless platform. They support powerful workflows, such as feature branches and pull requests, that make it easy to build production applications with the classic Val Town simplicity and lightness.

Learn more about Val Town Projects in our announcement post and docs.

Highlight to Edit with AI
We’ve yet again built a popular way to code with AI into Val Town. Select text in any val and then click Edit or Cmd+L to ask AI to rewrite that section of code.

This solves the problem with Townie rewriting too much or our completions not rewriting enough. Now you can highlight exactly what you want edited.

Huge shout-out to the folks at Marimo for open-sourcing this CodeMirror plugin!

Logs Redesign
We’ve redesigned our logs to be easier to read and navigate – with powerful filters to help you find what you’re looking for fast.

The new logs pair beautifully with Val Town Projects, letting you view all the logs across a project at once.

Public endpoints with private code
At long last, we’ve updated val privacy permissions to made it easy for you to create public HTTP endpoints, while keeping your code private.

Now Private keeps your code private, but your HTTP endpoint open. We’ve grandfathered old Private HTTP endpoints into a Legacy Private permission, which preserves the previous behavior by keeping the HTTP endpoint closed.

You can learn more about val privacy states in our docs. Thanks Robin Sloan, Matt Marcus, and Achille Lacoin for requesting this upgrade 🙏

Client-side errors in the HTTP preview
If your Val Town code throws an error on the server, you will see that in our beautifully-redesigned logs. But if your code throws an error on the client side, you’d have to seek in the browser console.

Now, we surface those client-side errors right in bottom of the HTTP preview, so you can see them right where you’re working:

To enable this, add this to your HTML:

We’ve instructed Townie to do this for you automatically for the last couple months (to enable its auto-detection of client-side errors), so some of your vals may already have it installed.

Markdown editor line-wrapping
You can now choose to wrap lines in our Markdown editor.

Projects API
The Val Town Projects Read API is out in beta. You can now list and retrieve public or your own projects and their branches and files. Here are the routes we currently support:
GET /v1/projects/{project_id}
GET /v1/projects
GET /v1/projects/{project_id}/branches/{branch_id}
GET /v1/projects/{project_id}/branches
GET /v1/projects/{project_id}/files
GET /v1/projects/{project_id}/files/{path}
GET /v1/projects/{project_id}/files/{path}/content
GET /v1/alias/projects/{username}/{project_name}

It’s already been useful. For example, the Project that lets you download Projects as zips is built on our these routes.

You can view the API docs and SDK docs to get started.

Other updates
• Increased the timeout of script, cron, and email vals on Pro from 5 to 10 min – thanks Nathaneal Silverman for requesting this 🙏
• Logs show up immediately after a val starts running
• Fixed a bug where crons would very rarely run twice – thanks Nathaneal Silverman and Sean Piefayth for reporting this 🙏
• townie.new?prompt= and val.town/townie?prompt= let you link someone to a new Townie chat with the input box pre-filled – thanks to our friends at Braintrust for requesting this and Nico for making a Raycast extension for it 🙏
• Ask you to name vals, files, and folders before creating them with random names
• Added a beautiful heart animation when you like a val
• Silence a particularly annoying JSX error in the TypeScript editor
• Moved the val full-screen editor button from the top nav to inside your profile menu
• Improved the error message when a val hits the timeout limit
• Improved the error message when you try to schedule a val more frequently than every 15 min on the Free plan
• Enabled esModuleInterop in the TypeScript editor
• Improved the security of your stored env variables
• Fixed a bug in our rate-limiter
• Fixed bug that prevented you from deleting comments on your vals
• Improved the subject line of notification emails
• Updated our onboarding survey to better personalize your experience

Roadmap
We have a new perspective building for AI coding at Val Town. We have paused all Townie development in favor of building out the Projects API and a CLI to edit vals locally, so you can edit vals from Cursor, Windsurf, VSCode, vim, etc.

Here’s what we’re working on next:
• Projects Write API
• Val Town Projects CLI
• Redesigned account-wide logs
• Customizable val.run domains for Project HTTP vals
• Faster & scalable runtime
• Bug fixes to our in-browser TypeScript editor
• Improved code search
• Metrics to track your usage and limits
• Comments on pull requests
• Team accounts
• SOC2 compliance
• …and much more!

Please make feature requests and vote on what you’d like to see next.

🌟 Community vals and projects
We have a new Community Showcase page to highlight some community vals and projects we feel inspired by. Go give these vals a like and a fork!
• Paul reimplemented source.unsplash.com with Val Town
• Linus Lee made an Email Research Agent, a lightweight wrapper around Perplexity’s Sonar API
• spag is an awesome tool for uploading and sharing files for music livecoding, made by Lu Wilson & Pasta Gang. You can see all their server code hosted on spag, spagUpload, spagDelete, and spagList.
• Jamie from Glif made a Discord bot to linkify messages in Discord
• Steve wrote about how he proposed to his girlfriend in Quordle
• Jordan made a val to parse Goodreads’ RSS feed to power his /reading page
• We made a new set of utils to help you build Projects more quickly, including reading files, serving files, writing tests, etc
• Max from Val Town made a status page to check the statuses of all of Val Town’s downstream providers to help him when PagerDuty wakes him up at 3am
• Em from Stainless made Regex to Brainrot, which gives you entertaining explanations for regex
• Jose Foronda made a Bolivian news digest for social researchers with Google Gemini
• Seflless made a val to parse Amazon order emails
• There were so many adorable forks of @mewtru’s Valentine’s card val including these from iLegacyy, saeed0x53, arshs13, dtang18, risha_narayanan, DannieP, and wabidu ❤️
• Alex from OneSignal made a queue and unique table in Val Town SQLite
• Juleeyet made a Language Translator
• Varun, a grad student at NYU, made a conversational AI app built with Cerebras
• Max from Canva made a Neocities hit counter
• Geordie created a Bandcamp CSV processor that processes Bandcamp Sales Reports.
• webmonk made SmartQuiz, an AI-powered quiz generator
• Em also made a memoization function and an HTTP cache to store and retrieve HTTP responses
• Steve made a “Run on Val Town” badge for the Steel TypeScript starter project
• @g made a text-to-speech app
• Kyle made a val that extracts and stores links from emails
• Ankur made a bookmark sync tool to keep bookmarks consistent across multiple browsers and save them
• Victor made helper functions for building with Twilio
• @Skeye made an RSS reader for the JavaScript Weekly newsletter
• @kailhus made a Mixcloud live check to determine if a specific Mixcloud channel is live
• Joey made a sauna temperature dashboard that displays real-time temperature data from his sauna
• @panphora made a Bluesky phrase tracker to monitor mentions via email
• @jxxe made LetMeIntoLinear, to snatch a spot in the Linear Algebra course at Brown
• Wolf made a Bing Image of the Day history tracker
• Steve and Rich Harris made a Svelte starter template for Projects
• Justin made Neighbor Solutions, a platform for connecting neighbors and sharing local resources.
• @hilmanski made a Google Rank Tracker to monitor website rankings for specific keywords.
• John built Globe, a 3D globe visualization using Three.js to display country information.
• wilt created an email to Discord webhook that forwards incoming emails to a Discord channel.

Original source Report a problem