petersalomonsen.com

wasm-git is a project by Peter Salomonsen that brings Git into web applications by compiling it to WebAssembly, so version control runs inside the browser instead of on a server. According to the site, it is used together with client-side encryption to give users full custody of their own application data, with complete change history — and, as the site notes, the responsibility that comes with holding your own keys. The latest demo runs entirely in the browser using OPFS (the Origin Private File System) and can sync through the NEAR blockchain.

The problem wasm-git addresses

Normally, when you use a web app, your data and its history live on someone else's server. You get whatever history the app chooses to show you, and the operator holds the keys. wasm-git moves that model: Git itself runs in the browser, so the repository and its change history belong to the user.

The site frames this as "Who really controls your data?" — an article about bringing Git to web apps so users get full custody of their application data, complete change history, and the responsibility that comes with holding their own keys.

How it works

Three pieces combine:

• Git compiled to WebAssembly — the version control operations execute client-side, in the browser, rather than on a remote host.
• Client-side encryption — data is encrypted before it leaves the user's control, so the storage layer does not see plaintext.
• A storage and sync layer — the latest demo uses OPFS for in-browser storage, with sync backed by the NEAR blockchain.

The result is a repository whose history the user holds, not the application operator.

Where it shows up in practice

wasm-git is not only a standalone demo — it is the delivery mechanism for other projects on the site:

• At the International Faust Conference 2026 in Cannes, the concert and the Faust-to-AssemblyScript demo loaded directly from git repositories stored on the NEAR blockchain via wasm-git.
• The WebAssembly Music environment uses the same approach: songs, Faust synth instruments, sequences and reactive visuals are code compiled to WebAssembly and running live in the browser.

What to keep in mind

Full custody cuts both ways. If you hold your own keys and your own history, no operator can restore access for you or quietly recover lost data. The site states this directly: holding your own keys comes with responsibility. Before adopting this model for a real application, decide who is accountable when a key is lost and how users will be expected to manage that.

Where to start

• Read the article "Who really controls your data?" on petersalomonsen.com for the reasoning behind wasm-git and client-side encryption.
• Try the latest wasm-git demo, which runs in the browser with OPFS and NEAR-backed sync.
• Explore webassemblymusic.pages.dev to see the same Git-in-WebAssembly approach applied to live-coded music.

A postal code API returns structured location data for a given ZIP Code or Canadian postal code. A typical response includes the code itself, city, state or province, county, latitude/longitude, and — where available — ZIP+4 detail. More complete services add time zone, area codes, boundary geometry, and demographic fields. You send a code (or an address), and the API sends back a machine-readable record you can store, validate, or display.

This article explains what those responses contain, how requests are usually shaped, and where postal code data fits into real applications.

First, clear up the word "code"

The keyword "code" is overloaded, and that causes real confusion for developers:

• Postal code — the ZIP Code (U.S.) or postal code (Canada) that identifies a delivery area.
• API key — the credential you use to authenticate your requests. It is not postal data.
• Source code — the program you write to call the API.

When someone searches for "postal code API code," they usually want example request/response code for a postal code service. The rest of this article treats it that way.

What a postal code API actually returns

Response fields vary by provider and endpoint, but the core set is fairly consistent. A single-code lookup commonly returns:

Richer datasets add 90+ fields: boundaries, population, income, elevation, and more. You rarely need all of them — request only what your application uses.

A representative JSON response

{
  "postal_code": "90210",
  "city": "Beverly Hills",
  "state": "CA",
  "county": "Los Angeles",
  "latitude": 34.0901,
  "longitude": -118.4065,
  "timezone": "America/Los_Angeles",
  "area_codes": ["310", "424"]
}

XML responses carry the same information in tag form. Choose based on what your stack parses most easily; JSON is the common default.

Common request patterns

Most postal code APIs support four patterns. Knowing which one you need prevents wasted calls.

1. Lookup by code

You have a code and want its details. This is the simplest and fastest call.

GET /lookup?code=90210

2. Reverse lookup by address

You have a street address and want to confirm or complete the code. This is the pattern behind checkout address validation.

GET /validate?street=...&city=...&state=...

3. Radius search

You have a center point and want all codes within a distance. Useful for store locators and delivery zones.

GET /radius?code=90210&miles=10

4. Batch validation

You have a file of addresses and want them cleaned in bulk. Batch endpoints trade latency for throughput and usually have their own limits.

Handling missing and ambiguous matches

Real data is messy. Plan for these cases:

• No match — the code doesn't exist or the address is malformed. Return a clear error rather than a silent empty object.
• Multiple matches — a city name may map to several codes, or a code may span several acceptable city names. Decide whether to pick the primary or return a list.
• Partial match — the street is valid but the ZIP+4 isn't. Fall back to the 5-digit code.
• Stale data — codes are added, retired, and reassigned. Refresh your dataset on a regular schedule.

A practical rule: validate at the point of entry, store the normalized result, and never re-derive it later from raw user input.

Practical use cases

• Checkout address validation — catch typos before shipping, reduce failed deliveries.
• Shipping zone lookup — map a code to a zone, carrier route, or rate table.
• Data enrichment — append county, coordinates, or demographics to existing records.
• Store and service locators — radius search to find nearby branches or coverage areas.
• Territory and tax logic — county and boundary data drive jurisdiction rules.

Licensing and data-source considerations

Postal code data originates with national authorities — USPS in the United States and Canada Post in Canada. Providers license and repackage it, which is why accuracy, update frequency, and field coverage differ between services. Before committing:

• Confirm the data source and how often it refreshes.
• Check whether ZIP+4 and boundary data are included or sold separately.
• Review usage limits and whether batch processing is allowed.
• Read the license terms for redistribution and storage.

Pricing and plan details change, so check the provider's current documentation rather than relying on secondhand figures.

Getting started

1. Decide which request pattern you need (lookup, reverse, radius, or batch).
2. Pick the fields you'll actually store.
3. Write a small test call and inspect the raw response.
4. Add error handling for no-match and ambiguous cases.
5. Cache results where the same codes repeat.

A postal code API is ultimately a translation layer: you give it a code or an address, and it gives back structured location facts. Understand the fields, match them to your use case, and handle the messy edges — that's most of the work.

Agentic composition on petersalomonsen.com is a workflow where you direct an in-browser AI agent inside the WebAssembly Music environment, and the agent writes and edits code — notes, Faust synth instruments, the sequence, and reactive visuals — which is then compiled to WebAssembly and runs live in the browser. The key condition is that you stay the composer: you direct the arrangement, play patterns in on a MIDI keyboard, and edit the code where it matters. It is not a "prompt-and-pray" generator.

What the agent actually produces

Everything in a track is code, not rendered audio files:

• Notes — the musical material itself
• Faust synth instruments — DSP definitions for the sounds
• The sequence — how the parts are ordered and triggered
• Reactive visuals — visuals that respond to the music

All of it is compiled to WebAssembly and runs live in the browser, so the song can be played and edited in place rather than exported and re-imported.

The composer's role

Peter Salomonsen describes the split explicitly: the agent writes and edits code on instruction, but he remains the composer. In practice that means:

• Directing the arrangement
• Playing patterns in on a MIDI keyboard
• Editing the code where it matters

This is the dividing line between agentic composition and prompt-only generation. The agent is a fast code editor inside a musical environment you control, not the source of the musical decisions.

A worked example: "Prompted"

The September 2026 track Prompted is an italo-disco instrumental in D minor where the notes, the Faust synth instruments, and the dancers themselves are all code compiled to WebAssembly.

The instructive part is the choreography. The agent knew the name of the dance move but not the move itself, so the instruction had to be specified foot by foot against the drum pattern. That is a useful illustration of where agentic composition breaks down: the agent can act on precise, decomposed instructions, but a label alone does not carry the physical or musical detail behind it.

The full agent session for this track was kept — 131 instructions — and published next to the sources in wasm-music-prompted. If you want to see what the process looks like in practice rather than in summary, that record is the place to look.

Where to see it running

• Play and edit live — tracks are playable and editable at webassemblymusic.pages.dev
• Watch — new WebAssembly Music tunes and videos appear regularly on the YouTube channel
• Source and session logs — published alongside the tracks, e.g. wasm-music-prompted

Related work on the same site

The agentic composition work sits alongside other projects that share the same browser-and-WebAssembly foundation:

• wasm-git — Git in WebAssembly, used to bring version control to web apps; the latest demo runs entirely in the browser using OPFS, with sync backed by NEAR
• faust2as — compiling Faust DSP code to AssemblyScript so it runs as WebAssembly inside the WebAssembly Music environment, demonstrated at the International Faust Conference 2026
• NEAR smart contracts — the blockchain side, including loading concert and demo content directly from git repositories stored on NEAR via wasm-git

Choosing whether this approach fits you

The practical takeaway: agentic composition here is a code-editing collaboration inside a live WebAssembly music environment. It rewards precise, decomposed instructions and a composer willing to keep making the musical calls.

Faust DSP code is turned into WebAssembly on this site through a tool called faust2as, which compiles Faust DSP to AssemblyScript so it can run as WebAssembly inside the WebAssembly Music environment. The demos and concert material that use this pipeline load directly from git repositories stored on the NEAR blockchain via wasm-git. That combination — Faust for the audio DSP, AssemblyScript/WebAssembly for execution in the browser, and NEAR-backed git for storage and distribution — is the core of how these pieces connect.

The three layers and what each one does

The setup separates cleanly into a language/compiler layer, a runtime layer, and a storage/distribution layer.

faust2as: Faust to AssemblyScript to WebAssembly

Faust is normally a DSP language with its own backends. Here the path is different: faust2as compiles Faust DSP code to AssemblyScript, which then compiles to WebAssembly. The practical result is that a Faust-described instrument becomes a WebAssembly module that can be instantiated and run inside the WebAssembly Music environment, rather than only in a native or standalone Faust context.

WebAssembly Music as the runtime

WebAssembly Music is the environment where the compiled instruments actually play. It hosts synthesis and sequencing, and it is where live coding and performance happen. So the Faust-derived WebAssembly modules are not standalone apps — they are components loaded into this browser-based music environment.

NEAR-backed git via wasm-git

The demos and the concert material do not load from a conventional server path. They load directly from git repositories stored on the NEAR blockchain via wasm-git. wasm-git is the project that brings git into WebAssembly, and here it is paired with NEAR so that the repository content lives on-chain and is fetched into the browser.

Where this was demonstrated

At the International Faust Conference 2026 (IFC 2026) in Cannes, the author showed how Faust DSP code can be compiled to AssemblyScript and run as WebAssembly inside the WebAssembly Music environment. The concert and the Faust-to-AssemblyScript demo both load from git repositories stored on the NEAR blockchain via wasm-git. The concert recording is online, with the author's own set starting at 1:27:30.

Why the combination matters

Each piece solves a different problem:

• Faust gives a concise, high-level way to describe DSP.
• AssemblyScript/WebAssembly makes that DSP run efficiently in a browser without native installs.
• wasm-git on NEAR gives the code a decentralized home with full history, so a performance or demo can be reproduced from the repository itself.

For anyone exploring this stack, the useful takeaway is the pipeline shape: write DSP in Faust, compile it toward WebAssembly through AssemblyScript, run it in a WebAssembly music runtime, and distribute the source through git stored on NEAR.

petersalomonsen.com is the personal project site of Peter Salomonsen, a developer who works at the intersection of code and music. It is not a product or a service you sign up for — it is a portfolio and writing hub where he publishes articles, live demos, and videos about WebAssembly music and synthesis, browser-based live coding, wasm-git, and NEAR blockchain smart contracts. He is also the author of Building and Deploying WebAssembly Apps. If you want to see what WebAssembly can do for audio and creative tooling, or follow along with the code behind the demos, this is the place to look.

The core themes

The site's tagline — "WebAssembly music, synthesis and NEAR smart contracts" — maps directly onto four recurring topics:

• WebAssembly music and synthesis. Tracks where the notes, the synth instruments, and even the visuals are code compiled to WebAssembly and running live in the browser.
• Live coding in the browser. An environment called WebAssembly Music where songs can be played and edited live, with Faust DSP code compiled to AssemblyScript (a project he calls faust2as).
• wasm-git. Git running inside WebAssembly, used to give web apps version history and to sync repositories stored on the NEAR blockchain.
• NEAR smart contracts. Blockchain-backed storage and sync, including loading demo content directly from git repositories on NEAR.

What you'll actually find there

The site is organized as a running log of projects, each with links to sources, live demos, and video:

How to use the site

There is no account, download, or pricing to worry about — it is a reading and demo site. A practical path:

1. Start with the live demos. Open webassemblymusic.pages.dev to play and edit songs directly in the browser; this shows the concept faster than any description.
2. Read the write-ups for the parts that interest you. The "Who really controls your data?" article is the entry point for the wasm-git and data-custody thread; the "Prompted" and agentic composition posts cover the AI-assisted music workflow.
3. Follow the source links. Each project links to its repository (for example, wasm-music-prompted), so you can read the actual code rather than just the summary.
4. Watch the videos if you prefer seeing the tools in action, including the IFC 2026 concert recording (his set starts at 1:27:30).

Who it's for

This site is most useful if you are a developer interested in WebAssembly as an audio platform, in live-coding music in the browser, or in running Git and blockchain-backed storage client-side. It is less relevant if you are looking for a commercial product, a library with documentation and support, or a general music site — the content is one person's experiments and writing, presented as articles, demos, and videos rather than as a maintained product.