Write Solana programs in HTML.

Quick start

The compiler is an ES module served from this site. Import it straight from the URL in a browser, or download it once for Node.

Try it here

This box runs the real module from /lib/htmlsol.js. Break a tag and press Compile.

Your first program

A counter that only its owner can increment. Two accounts, one argument, one rule.

Read it top to bottom. <table> says what a Counter account stores. Each <form> is an instruction. Inputs come first: accounts in the order the client passes them, then arguments in the order they are packed. Then statements run top to bottom.

The increment form above turns into 17 lines of C with seven checks: account count, signature, writable, owner, size, discriminator and data length, plus the require and checked math. Open it in the Playground to see every line.

How it works

1. Parse. A forgiving tokenizer reads tags, attributes and text, with line numbers. Comments and <!doctype> are dropped. Unlike a browser, unclosed containers are errors.
2. Check. Names, types, table fields and account flags are resolved. Writing to an account without mut, comparing a key with a number or using an undeclared name stops the build with a message and a line.
3. Generate. Each form becomes a C function; an entrypoint reads the 8-byte instruction discriminator and dispatches. Account checks come first, then argument reads, then your statements.
4. Describe. The same tree produces the IDL and the client, so all three always agree.
5. Build. You run clang from Solana platform-tools on the C. That step happens on your machine, not in the browser.

Programs and tables

Every file has exactly one <program id="name">. Everything else lives inside it. <html>, <body>, <center> and <div> around it are allowed and ignored, so a program can also be a valid web page.

A <table id="Name"> declares an account layout. Each <td name type> is a field. Closing </td> is optional, and <tr> rows are flattened if you like your tables proper.

The account's data is an 8-byte discriminator followed by the fields, packed, in declaration order. A Counter with a pubkey and a u64 takes 48 bytes.

Forms and inputs

<form action="name"> is one instruction. Inputs must come before the first statement. Account inputs are numbered in the order they appear; that's the order a client must pass them.

Statements

Statements run in order. Values can be number literals, true/false, an argument name, account.field, account.key or account.lamports.

Writing to .lamports moves SOL directly. The runtime only allows it to take lamports from accounts your program owns, and the total has to balance by the end of the instruction.

Transfers with <a>

A hyperlink that pays. <a href="system:transfer"> makes a cross-program call to the System Program and moves lamports from a signer to any writable account.

Requirements the compiler enforces: the form has a type="program" input, from is a signer, both ends are mut. Only system:transfer is supported in 0.1. Calls to other programs are planned as <iframe>.

<marquee> and <blink>

<marquee times="N"> repeats its contents N times, from 1 to 64. A marquee with no times doesn't compile: it would scroll until the runtime ran out of compute.

<blink>text</blink> writes a line to the transaction logs with sol_log. It costs about 100 compute units plus the length of the text, so it's the priciest tag in the language.

Errors

Declare errors with <error name="Name">message</error>. Codes start at 6000 in declaration order, or set one with code. A <require> naming an undeclared error gets the next free code and its name as the message.

Every failed require logs the code, the name, the message and the source line, like Error 6000 Unauthorized: Only the counter's authority can change it (counter.html:20).

Tags reference

Any other tag is ignored with a warning, so <p> and <div> are free documentation.

JavaScript API

lines is the C as [{ text, src }], where src is the HTML line that produced it. The homepage uses it to draw the wires between the two panels. estimate is { bytes, cu: { [instruction]: number } } from the compiler's cost table.

IDL format

Anchor's IDL spec: address, metadata, instructions with discriminators, accounts and args, accounts, types and errors. Pass { address } to compile to fill in the program id.

Generated C

The output includes solana_sdk.h and nothing else. Each form becomes ix_<name>; the entrypoint deserializes accounts with sol_deserialize, reads the discriminator and dispatches. Structs are packed, math uses __builtin_add_overflow, keys are compared with SolPubkey_same.

Don't edit the C. Change the HTML and compile again; the header says so too.

Error codes

Build and deploy

You need the Solana CLI, which ships platform-tools with clang for SBF. Put the generated C in src/counter/counter.c and add a two-line Makefile that includes the SDK's C build rules.

Deploying again to the same program id upgrades it. Put the id into compile(src, { address }) so the IDL and client carry it.

Calling it from a client

The Client tab in the Playground and out.client give you one instruction builder per form for @solana/web3.js. Creating and initializing a counter in one transaction looks like this:

Limits and threat model

What the compiler guarantees: every account a form names is checked for count, signature, writability, ownership, size and type before your statements run; arguments are length-checked; math is checked; errors carry their source line.

What it doesn't do in 0.1:

• No program-derived addresses yet. Accounts are created by the client and passed in.
• No closing or resizing accounts.
• Calls to other programs: System Program transfers only.
• Integers, booleans and keys only. No strings or arrays in tables.
• Compute and size numbers are estimates from a cost table, not measurements.
• The compiler hasn't been audited. Read the generated C before you put real money behind it, the same as any code.

$HTML

The token of the only compiler that accepts <marquee>. The compiler itself is free and stays free: it's a file at /lib/htmlsol.js.

Only trust the contract address published on the homepage; this page reads it from there.

FAQ

Changelog

0.1.0 · 2026-10-28

• First release: <program>, <table>, <form>, all input types, <require>, <set>, <add>, <sub>.
• <a href="system:transfer"> System Program transfers.
• <marquee times> loops and <blink> logs. <center> accepted.
• Anchor-format IDL and a web3.js client generator.
• Playground with sharable links.

Next

• <iframe src="program:…"> for calls to any program, from its IDL.
• Program-derived addresses with <input type="account" seeds>.
• W3C validation and 1.0.