Val Town Release Notes

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

Since we published this blog post, we decided to unify our two primitives—vals and projects—into a single primitive: the val, with the best features of both. Read more about how we are upgrading all vals on our platform here.

Today we’re releasing Val Town Projects in public beta to unlock a whole new level of complexity for what you can build in Val Town. Projects are groups of vals, files, and folders that are versioned collectively, and deployed on our serverless platform. They support powerful workflows, such as feature branches, that make it easy to build and deploy large applications.

Vals are too small

Projects solve the biggest problem with Val Town: vals are too small. A val is just a single file.

Despite that, you all have built incredible things with vals. Recently we’ve seen a transcription app, a p2p file transfer service, a Linear & Github daily LLM summarizer, citizen data journalism, and much more.

But vals become unwieldy after a couple hundred lines of code. The pain is especially acute when using an LLM to edit or rewrite hundreds of lines in a single val file.

Unfortunately, things get worse if you break up a single val into multiple vals that import each other. For example, I broke up the Date Me Directory, an alternative dating website, into a handful of vals, one for each page in the site. Whenever I want to make a change without affecting production, I need to manually fork each of those vals one-by-one, and then manually update all the imports in each of them to point to the forked versions. Then getting the changes back into the production vals was similarly miserable.

Instead most users either stuff all their code into a single super long val or just made all their changes directly to their main production vals (sometimes breaking it briefly). Or they moved off Val Town entirely. We needed a solution to dramatically increase the scope of what you can build on Val Town.

Enter Val Town Projects

Val Town Projects are groups of vals, files, and folders that are versioned, branched, forked, and merged collectively. With Projects, you can create feature branches and test changes without affecting production.

As you may know, Val Town deploys your code in 100ms. This is a magical way to code directly in the cloud – instead of on localhost and deploying to the cloud later. This kind of live feedback loop is incredibly fun. It’s almost addicting. It also means that you are building in the exact same environment that you deploy in, cutting out all the complexity of managing multiple environments.

But just because you’re deploying to the cloud on every save doesn’t mean you want to deploy to production on every save. Val Town Project branches give you the best of both worlds: you can rapidly prototype in the exact same environment that you’ll deploy to, but without affecting production. It’s like localhost and PR previews had a baby: super fast iteration cycles, paired with immediately hosted URLs you can share.

And the final kicker is scale. Once your app is running on Val Town, it’s fully deployed and you can rest easy. You don’t have to worry about provisioning more or less compute: our serverless platform will automatically scale your app to handle any number of users. To be clear, our Scale Plan is slated to launch in Q2 2025. Currently, Val Town scales to 100k and 1m runs per day on the Free and Pro plans, respectively.

Projects are not git repos

We considered building Projects as git repos, but decided that becoming a git host at scale was too much complexity for the small subset of git’s features that we wanted (diffs, branches, merges). We realized that it’d be much simpler to build our own version control system.

This sounds like sacrilege – even to us. Everyone at Val Town is a happy git user. Yet if you think about it, many pro tools had to build their own version control, including Google Docs, Figma, and Notion. We feel heartened to hear how speculative and uncertain this decision felt at Figma – to build their own multiplayer system instead of using OTs (operational transforms), which was the standard at the time given its success in Google Docs.

“As a startup we value the ability to ship features quickly, and OTs were unnecessarily complex for our problem space. So we built a custom multiplayer system that’s simpler and easier to implement.
At the time, we weren’t sure building this feature was the right product decision. No one was clamoring for a multiplayer design tool—if anything, people hated the idea.
…Our bet paid off, and these days it’s obvious that multiplayer is the way all productivity tools on the web should work, not just design.
– Evan Wallace, Co-founder, Figma, How Figma’s multiplayer technology works”

We too built something that nobody was clamoring for, but that we hope will seem obvious in the retrospect. Experienced programmers will feel right at home in Val Town Projects – branching, forking, merging, and pull requesting – collaborating directly within the same platform that you’re iterating and deploying on.

New programmers might never need to learn git at all. I can still remember the frustration of learning git for the first time, and I’m excited to think that we might be able to save a new generation of programmers from that pain. Particularly in this new age of LLM programming, we think there’s an opportunity to build something simpler.

And if you really need git, Projects are git-friendly, so we will soon build a way to sync them to and from a git repo. We’re racing to release a Beta API for Projects, which will allow you to have full control over your source code, sync to and from a git repo, and wherever else you want.

Learn more about Val Town Projects here in our docs.

What you can build

Up till now, Val Town has excelled at small pieces of code, such as little integrations and automations, such as social media monitoring, data sync, and single-page sites. We’re excited to see what you can build with a much larger scope in Projects, such as:

• internal tools
• durable workflows
• a backend for your app
• API prototypes – like Campsite, Glif
• a starter template for your API – like PostHog, Framer, tldraw, Browserbase,
• multi-page, full-stack apps

We want to highlight the biggest Project built so far. Nathanael is building JournalGroove, an app to help people get more insight from their journaling practice. The frontend of the app is simply Notion, and the backend is hosted on Val Town. Nathanael has a series of cron vals that run throughout the day to process your latest journal entries and deliver personalized, AI-generated reports back into your private Notion space.

Before Projects, Nathanael had dozens of vals scattered across folders, and versioned separately. He was able to migrate them all into a single Val Town Project in about 30 minutes.

“Val Town enabled me to grow this from an idea into a fully-fledged project much faster than I would have expected. I like that Projects are separate from my other random vals. And I look forward to using branches, eventually collaborating with other people.”

• Nathanael Silverman

Start building

You can start building with Projects right now.

We can’t wait to see what you build! If you’re new to Val Town, you can sign up free here.

Original source Report a problem

🥳 Happy 2025!

Last year, our product grew from a JavaScript playground to a stable FaaS (Functions as a Service) platform that thousands of engineers use in personal and professional contexts. Some highlights from 2024:

• Raised our seed round
• Max, Jackson, Justin, Sophie, and Charmaine joined our team
• Our infra became fast and stable
• Launched Townie, a shockingly useful code assistant
• 23k of you made 135k vals that’ve run 214m times

We have big plans for 2025. By the end of this year, we aim to be a mature cloud platform that serious engineering organizations use for core infrastructure. Here’s some of the highlights:

• Projects – groups of vals, files folders – with forks & 3-ways merges (currently in private beta)
• Scalable infra & usage-based billing
• Team accounts for companies to collaborate
• Improvements to Discovery, Search, Townie, Observability
• Continuing to fast-follow with LLMs
• SOC 2

We have two new additions to the Val Town team!
Sophie is a designer, programmer, and artist, who just moved from Berlin to join us here in Brooklyn. She’s best-known for a viral app she made as a teenager, but most recently worked with Nike and Delivery Hero.
Charmaine is a technical product manager, with a deep background in developer tools. She’s worked at Snapchat, Unity Labs, and Microsoft. We’re thrilled to have them both on board.

Val Projects Beta

Vals are great for small projects, but what if you want to build something bigger?
Introducing Val Projects, a new way to organize multiple vals, files, and folders into a single place. Where a Val Town Val is like a GitHub Gist, a Val Town Project is like a GitHub Repo.

Projects support:

• Static assets, like images, videos, CSS, HTML, and more
• Multiple files and folders
• Scoped environment variables (that code outside the project can’t access)

Projects will soon support:

• Branches, forking, pull requests, and three-way merges
• Townie, with the ability to understand and edit multiple files

Projects are currently in private beta. We’re looking for more passionate Val Town users to try it out and give feedback. If you’re a Pro user, please reach out to [email protected], and we’ll add you to the beta.

Templates

“What can I do with Val Town?” We get this question a lot, so we made a page to help answer it.
Check it out and see if it sparks any ideas for you! Maybe you’ll find a val that’s perfect for your needs and you can fork it and make it your own. If you don’t find what you’re looking for, let us know. If you want to submit a val to be included, we’d love that too!

Upgraded to Deno 2

Deno 2 is out, and Val Town is now running it. We’re currently on Deno v2.1.2, but you can always check which version we’re running here.

In addition to some performance and security upgrades, Deno 2 also includes a couple exciting features:

• process and Buffer are now globally available, which means you don’t have to import them anymore, which increases compatibility with Node.js code (example)
• WebAssembly imports are supported out-of-the-box (example)

Updated pricing

We made three changes to our pricing:

1. We now have a yearly plan for $100! This is a 20% discount on our monthly plan 🥳
2. We’ve explicitly listed custom domains on the Pro plan, with a limit of 10
3. We’ve changed the val runs limits from per minute to per day. Now you get:
   • Free: 100k runs / day
   • Pro: 1m runs / day

One final word to the wise: we plan to increase our pricing soon, but existing customers will keep the same price, so sign up soon!

Blogs, podcasts, and livestreams

There’s been a lot of great content about Val Town recently, a podcast, a livestream, 5 blogs, and (unfortunately) 2 post-mortems:

• 📺 Every Podcast: Do a 60-Minute Coding Task in 60-seconds with Steve Krouse
• 📺 Finsweet livestream: Exploring Val Town to supercharge your Webflow projects ft. Steve Krouse
• 📝 Turning data into calendar feeds by Matt Rossman about how to get any data onto any calendar app supports iCal (which is all of them) super quickly
• 📝 Reimplementing Unsplash Source by Paul Esch-Laurent about reimplementing the now discontinued Unsplash Source API
• 📝 Using Val Town to chart dependency bloat by Tom MacWright about Devstats, a val lets you post statistics from your GitHub Actions runs to build charts of change over time
• 📝 Bandcamp wrapped by Tom MacWright about a val that generates a Spotify Wrapped-style report for your Bandcamp purchases
• 📝 What we learned copying all the best code assistants by Steve Krouse
• 📝 Post-mortem: esm.sh breaking changes – esm.sh unexpectedly released breaking changes that impacted 2% of Val Town users
• 📝 Post-mortem: Exhausted Host Connection Pool – one of our servers had degraded performance due to a deadlock

Other updates

• The logged-in Val Town homepage is now the dashboard, which shows your recent vals and projects. You can find the old homepage at val.town/home.
• We updated val Run & Save buttons to be easier to find, and provide more immediate feedback

🛣️ Roadmap

• Val Projects
• Faster & scalable runtime
• Observability upgrades: searchable & filterable logs and traces
• Metrics to track your usage and limits
• New Explore page for discovering vals
• Improved code search
• Comments on pull requests
• Team accounts
• Ability to follow a Val Town user
• SOC2 compliance
• …and much more!

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

🌟 Community vals

• Steve relaunched Cerebras Coder, an app that generates websites in under a second. Over 100k projects have been created with it!
• Paul, who leads Chrome’s Developer Relations team, made an Email Summary Service for newsletters
• Michael from Notion made a Notion web clipper to save Notion content to Wallabag
• Ellie Huxtable added a “recent listening” widget to their website
• Sam powers the “Latest YouTube video” part of his site with data from a val (post on bluesky)
• Bao, an iOS engineer at Notion, created the Cipher Challenge, a game to decode a letter substitution cipher as quick as you can. It’s even multiplayer! (post on bluesky)
• Bryce made a daily email digest of a github repo’s activity (post on bluesky)
• Morry made a website where people can take pictures of his cats in his window and submit them via QR Code + email
• Prasham made a Val Town README Generator - type in your username and val’s name and it’ll generate a readme with AI you can copy and paste
• Max used vector embeddings to get “vibes” search on emojis
• John made cron vals to snipe hard to get nintendo museum tickets
• Jan made a fresh - an invoice generator
• Prasham made a calendar app for viewing ICS files
• Steve made a val that shows the top 100 Val Town users by number of public vals - did you make the cut? (tweet)
• Steve from tldraw made an example custom endpoint for tldraw computer’s data component. Jordan agrees that tldraw and Val Town are besties
• Victor made Let Him Cook, which lets you query database with natural language via email
• Mixer made a val to show their Spotify Listening History
• Trent built a val that calls him via Twilio whenever it receives a webhook
• Charmaine made Townie her personal illustrator
• Steve made an Anonymous doc publishing tool
• Colin from Zod built Josh Goldberg a mood diary
• David made AI Rapped 2024
• Danny made Interruptible Chain, a simple interface for pausing and resuming execution chains
• Vlad made a val that converts Bluesky Threads to RSS
• Nolen made the opengraph image for everyuuid.com with a Townie app he made
• Charmaine added a new Reddit Keyword Alerts template with an SMS version
• Victor made BYOB, Build Your Own Bot
• Boris made a cyberpunk weather display with Townie
• Jackson made GitHub Sync to sync vals from Val Town to GitHub and back
• Chet made a Landscape Lighting Calculator with Townie in minutes
• Mariano showed his users how to extend his app with a val
• Danny made expiringBlob, create-and-forget blobs using UUIDv7
• Adtiya from AWS made a site that gives you ideas from arXiv papers
• Peter made a dashboard that shows the most popular wikipedia articles in a given time range
• Inferable made an integration with Val Town to create AI agents
• John embraced Scott Belsky’s DIY software and made a 1000 hours outside challenge tracker
• Jamie from Glif made a val that fetches details about media files (images, video, audio, etc) using Mediainfo.js. e.g. codecs used, duration, file sizes, ID3 tags, etc.
• mint made a Annas Archive/Libgen+ OPDS library catalog (tweet)
• Dave made a holiday drink menu with Townie (post on bluesky)
• Dean made a game out of captchas
• Ben made a site for friends to cast predictions on the game awards (post on bluesky)
• Arfan made a kanban board todo list (as of this writing it was broken, but this fork works)
• dh1011 made a tool to extract important quotes from an article

Edit this page

Original source Report a problem