slot —— TPS

prompt.txt · template engine 1.0

Describe a Solana program. Forge a scaffold you can read.

Rules, not a language model. The same words always produce the same files: an Anchor outline, tests, a frontend, an IDL with real discriminators, and a deploy checklist.

Modules auto-detected
Nothing leaves your browser.

explorer

    —

    build timeline

    idle
      ready — files — lines rent — spec —

      02 — engine

      You can see exactly why each file exists.

      Forgekit tokenises your description and matches it against a fixed rule table. Every module it picks is traced back to the words that triggered it. Toggle modules by hand and the trace says so.

      No model, no server, no randomness. If two people type the same thing they get the same forgekit.spec.json, byte for byte, and the same SHA-256.

      Trigger words in your prompt (left) wired to the modules they select (right).

      03 — modules

      Ten building blocks, sized to the byte.

      Each module brings its accounts, instructions, errors and checklist items. Account sizes are computed the way Anchor's InitSpace does it, plus the 8-byte discriminator.

      04 — costs

      What it costs to put this on chain.

      Rent is protocol arithmetic: (128 + bytes) × 3,480 × 2 lamports per account. Fees come from live priority-fee percentiles, and SOL is priced live. The account rows are filled from your current scaffold.

      Accounts, sizes and expected counts
      AccountBytesCountRent eachTotal SOL

      Model default from instruction count. Replace with ls -l target/deploy/*.so.

      Program rent (locked while deployed)
      ——
      Deploy write transactions
      ——
      Temporary buffer (refunded)
      ——
      State rent at the counts above
      ——
      Fee per user transaction
      ——
      Monthly user fees
      ——
      Fund the deployer with at least
      ——

      Fees: loading live percentiles…

      on-chain proof · checking…

      SysvarBytesLamports heldFormula

      05 — discriminators

      The first eight bytes, computed in front of you.

      Anchor tags every instruction and account with the first 8 bytes of a SHA-256 hash. Forgekit computes them with WebCrypto and writes them into the IDL and the frontend's account decoder.

      preimage
      —
      sha256
      —
      bytes[0..8]
      —
      hex
      —

      Discriminators in your current scaffold
      NameKindBytes

        06 — checklist

        Ship it the boring, careful way.

        A deploy checklist built from the modules you chose. Progress is saved in this browser, keyed to your spec hash, so a new scaffold starts a fresh list.

        0%0 of 0

          07 — network

          The chain you are about to deploy to, right now.

          Read-only JSON-RPC through this site's own /api/rpc, refreshed every 20 seconds.

          slot

          —

          block height —

          epoch

          —

          —

          transactions per second · last 30 min

          —

          slot time

          —

          average over the samples

          priority fee · µlamports/CU

          p50
          —
          p75
          —
          p90
          —
          max
          —

          SOL

          —

          Jupiter price v3

          slot stream · paced at the measured slot time

          Illustration timed by live data: one block per slot. Slot numbers are not shown because between polls they would be estimates.

          08 — package

          Take the whole project with you.

          The zip is assembled in your browser: every file is UTF-8 encoded, checksummed with CRC-32 and stored. Nothing is uploaded, and there is no account to create.

          —

          Files in the package
          PathBytesCRC-32

          09 — faq

          Plain answers.

          Is this AI?

          No. Forgekit is a deterministic template engine with a fixed rule table. It reads keywords, picks modules and fills templates. That is why it can promise the same output for the same input, and why it is honest about what it cannot do.

          Will the generated program compile?

          It is written to Anchor 0.30 conventions and is meant to be close, but it is an outline: token transfers and some validations are left as clearly marked TODOs. Treat it as a well-organised starting point, then build, test and review it.

          Does Forgekit deploy anything?

          No. It never connects a wallet, never signs and never sends a transaction. The cost calculator tells you what a deployment would need; you run anchor deploy yourself.

          How accurate are the rent numbers?

          Rent uses the protocol's own constants and is checked live against five sysvar accounts, which hold exactly the rent-exempt minimum. The program-size figure is a model until you type in your real .so size.

          Where do the live numbers come from?

          Slot, epoch, TPS and priority fees come from Solana JSON-RPC through this site's read-only /api/rpc proxy. The SOL price comes from Jupiter's public price API.

          What is stored about me?

          Only your checklist ticks, in this browser's local storage. There are no accounts, cookies or analytics in this page.

          Why only ten modules?

          Each one is written by hand and kept small enough to read. Breadth would mean shallower templates. Combine modules in one prompt and the engine merges their accounts and instructions.