Pebble + Gerolamo - HLabs 2026 Budget

Budget Breakdown

The full budget breakdown is given below.

For a fair valuation of the proposal, we will follow a similar process to what is used in the Amaru proposal, which we believe is setting a good standard in terms of Treasury budget proposals, and we will estimate the scopes of this proposal in FTE (Full-Time Equivalent), which we will consider to equal a figure of $225k yearly rate.

We use a conversion rate of 0.35 ADA [₳] per USD [$].

Complete View

Scope	Estimated (FTEs)	Project Total ($)
Gerolamo (TypeScript Cardano node)	5	$1,125,000
Pebble (programming language + dApp development tools)	3.5	$787,500
Hard-fork maintenance	1.5	$337,500
Total	10 FTEs	$2,250,000

Cost Rationale

The total ask for the project is 10 FTEs.

FTEs are being valued at an annual rate of $225k.

Furthermore, we are aware of our assumption/optimism bias (our forecast is subject to underestimating complexity, overlooking challenges, and undervaluing the time and cost required to deliver, as well as our biased expectation of market movements). We therefore add an extra 25% contingency buffer, learning by our past mistakes.

This leaves us with the following total: (10 x $225k) x 1.25 = $2,812,500

Finally, using a conversion rate of 0.35 ADA per USD, we formulate a budget ask of ₳8,035,714. A complete breakdown of this budget is available below.

Milestones

This proposal spans Q2 2026 through Q1 2027, with milestones organized by quarter.

Q2 2026 (Apr–Jun): Hard Fork Readiness & Foundations

• Hard-fork maintenance: all TypeScript libraries updated for the upcoming hard fork
• Gerolamo: improve storage and networking for browser environments;
• Pebble: complete the type system; support for upcoming hard fork changes

Completion evidence:

• All relevant libraries maintained by HLabs support the Hardfork
• Gerolamo syncs to tip on public test network
• Multiple (≥3) pebble contracts of various complexity compiled end-to-end to valid on-chain code

Q3 2026 (Jul–Sep): Core Delivery

• Gerolamo: initial server-side relay capable release
• Pebble: additional key language features, such as namespaces, tests and more comprehensive standard library

Completion evidence:

• Gerolamo server-side relay syncs and follows chain tip on public test network
• Gerolamo relay published as installable release
• New language features implemented (e.g. namespaces, tests, standard library)

Q4 2026 (Oct–Nov): Integration & Browser Support

• Gerolamo: browser light node capable of syncing and serving chain data; compatibility with existing Cardano tooling
• Pebble: complete IDE integration & CLI + push for developers onboarding

Completion evidence:

• Browser demo syncing and querying chain data without a backend server
• Standard Cardano tool (cardano-cli or cardano-db-sync) successfully connects to Gerolamo
• Pebble IDE extension published with syntax highlighting and inline errors
• Pebble CLI build command working on multiple projects

Q1 2027 (Dec–Mar): Production Readiness, Documentation & Adoption

• Gerolamo: production-ready browser light node; performance validation
• Pebble: interactive console, documentation, tutorials

Completion evidence:

• Major browsers where Gerolamo runs as a light node (Chromium etc.)
• Gerolamo browser node reaches a "trustless" tip, eventually over multiple sessions
• Gerolamo maintains stable peer connections for ≥24 hours
• Pebble language features documented with examples
• End-to-end tutorials published

Budget Administration and Governance Oversight

Smart Contract Escrow

Funds are held and released through the SundaeLabs treasury-contracts (https://github.com/SundaeSwap-finance/treasury-contracts), a proven framework with two validators:

treasury.ak: Holds all ADA withdrawn from the Cardano treasury. Everything gets locked here when the governance action is enacted.
vendor.ak: Manages milestone-based vesting for HLabs. Payment schedule, payout dates, release conditions.
Both contracts have been independently audited by TxPipe and MLabs and are in production use on mainnet.

Independent Oversight Board

An independent oversight board provides third-party governance:

Santiago Carmuega (TxPipe, Dolos)
Lucas Rosa (Aiken, Starstream, Midnight)
Chris Gianelloni (BlinkLabs, Dingo)

Board members don't have a stake in HLabs. They co-sign disbursements, review milestones, and can halt funding if we're not delivering.

Permission Scheme

The actions allowed by the escrow contract are as follows:

Disburse (periodic release): HLabs initiates + any 1 board member co-signs
Sweep early (return unused funds): HLabs + any 1 board member
Reorganize (adjust milestone schedule): HLabs only
Fund (initial vendor setup): Board majority
Pause milestone: Any 1 board member
Resume milestone: Board majority
Modify project: HLabs + board majority
Day-to-day operations need one board signature. Structural changes need the full board. And any single member can hit pause if something looks off.

Delegation Policy

The treasury contract enforces auto-abstain DRep delegation and no SPO delegation for all funds in escrow. Treasury funds don't influence governance votes or staking.

Failsafe Sweep

Funds left in the contract after expiration automatically sweep back to the Cardano treasury. Enforced at the contract level. Can't be overridden.

Constitutionality Checklist

In an effort to convince ourselves of the proposal's constitutionality, we thought relevant to include a checklist of the points we cover and for each, our interpretation of the Cardano Constitution.

Purpose

• This proposal is for work intended to enhance the security, decentralization and long-term sustainability of Cardano.

Article III.5: the process of on-chain governance

• We have submitted this proposal in a standardized, legible format, which includes a URL and hash of all documented off-chain content. We believe our rationale to be detailed and sufficient. The proposal contains a title, abstract, reason for the proposal and relevant supporting materials.

Article IV.1: proposing budgets

• This proposal accords with the provisions of this article as it is intended to cover the maintenance and future development of the Cardano Blockchain.

• This proposal covers a 12-month (73 epochs) period as recommended by this provision of the Constitution.

Article IV.3: Net-Change Limit

• Budgets needs not to be evaluated within the context of a Net-Change Limit, only withdrawals must. However, we recognize that the establishment of a new Net-Change Limit will likely be necessary in order to enact withdrawals pertaining to this budget. We will re-assess the situation in due time, and possibly split withdrawals into multiple ones should it be required.

Cardano 2030 Strategic Alignment

• This proposal directly supports the Cardano 2030 Strategic Framework, contributing to the "Alternative full node clients" KPI (Pillar 1: Security & Resilience) and Developer Experience priorities (Pillar 2: Adoption & Utility).

• Measurable adoption indicators have been defined to provide visibility into ecosystem-level KPI contributions (TVL, monthly transactions, MAU).

Budget Detailed View

Gerolamo (Typescript cardano node)

repo

Main Objective
production-ready light node for dApps & wallets

Gerolamo is a TypeScript implementation of the Cardano node designed for:

• Browser compatibility: Serving as a base for nodes running in browsers
• Extensibility: Being the base for purpose-specific nodes (light nodes, UTxO-only nodes, chain indexers)

Full Ledger Rules Coverage Goal

Implement complete ledger validation rules to enable Gerolamo to fully validate blocks and transactions according to the Cardano protocol specifications.

Key Results

• Full ledger state management using LMDB (or IndexedDB for browsers) for performance improvements.
• Consensus implementation (Praos) with chain selection and rollback handling
• Volatile DB for managing chain forks
• Block and transaction validation covering all eras

Estimated Effort

2.5 FTEs

Node APIs Goal

Provide comprehensive APIs for dApp developers and infrastructure operators to interact with the Cardano network through Gerolamo.

Key Results

• UTxO RPC endpoints for efficient UTxO queries
• Local socket support for node-to-client protocols (cardano-db-sync, cardano-cli compatibility)
• Browser API for dApps to use

Estimated Effort

2 FTEs

Plutus Machine Improvements Goal

Continuously improve the plutus-machine CEK interpreter for better performance and full conformance with the Plutus specification.

Key Results

• Performance optimizations for script evaluation
• Budget tracking and cost model accuracy improvements
• Sourcemap support for debugging

Estimated Effort

0.5 FTEs

Gerolamo Summary

• total resources estimated: 5 FTEs

Production Readiness Criteria

Gerolamo will be considered production-ready as a browser light node when it meets the following objective criteria:

Criterion	Requirement	Verification Method
Sync reliability	Successful sync from genesis to tip on mainnet	Continuous integration
Sync performance	Initial sync ≤48 hours on commodity hardware (4 CPU, 16GB RAM)	Benchmark suite
Peer connectivity	Stable connections with ≥15 peers for ≥24 hours	Network validation
Block propagation	Block relay latency within 2x of Haskell node baseline	Comparative benchmarks
Rollback handling	Successful recovery from rollbacks up to k=2160 blocks	Adversarial scenarios

Value Proposition vs. Other Node Implementations

Dimension	Haskell Node	Amaru	Gerolamo	Gerolamo Benefit
Runtime	GHC runtime	Native (Rust)	Bun/Node.js/Browser	Runs anywhere JavaScript runs, including browsers
Browser support	No	Limited support planned (WASM, EOY 2026)	Yes (IndexedDB + WebWorkers)	Production-ready browser support sooner
Developer access	Haskell expertise required	Rust expertise required	TypeScript/JavaScript	Largest contributor pool (17M+ JS/TS developers)
Extensibility	Cardano-specific	Rust crates ecosystem	npm ecosystem integration	Seamless integration with web/dApp tooling
Use cases	Full block production	Full block production	Browser light node, data node, relay	Complementary; JS/TS native browser capability

[!NOTE]
Gerolamo is designed as a complementary implementation focused on browser light node and data-node use cases, not a replacement for block-producing nodes yet. Block production so far remains on the Haskell node.

Getting to a point where the node can be considered seriously as a production-ready light node, functionality wise, should get us pretty close to a point where it can also be used for block production.

however, enabling block production in a mainnet environment, would incur in a serious increase in the funds we would need to ask

for the security audit alone, the amaru and blinklabs teams are asking an additional 500k USD, which we believe to be appropriate.

additionally, if we were to include block production between the goal of this year, we'd also need to increase the estimated effort by at least 1 more FTE.

should the condition allow the next year, block production will be strongly considered.

given the current environment we decided it would be best to cut those efforts in order to contain the costs.

Pebble (smart contract programming language)

repo

Main Objective
production-ready language & tools

Pebble is a simple, yet rock solid, functional language with an imperative bias, targeting UPLC (Untyped Plutus Core). It provides developers with an intuitive syntax while compiling to highly optimized on-chain code.

Compiler Stability Goal

Achieve production-grade compiler stability with optimized code generation.

Key Results

• Comprehensive type system with full type inference
• Optimized UPLC code generation with minimal script sizes
• Complete error reporting with actionable messages
• Support for Plutus V4
• Key language features: namespaces, built-in test support, comprehensive standard library
• Documentation and tutorials for onboarding new developers

Estimated Effort

2 FTEs

Developer Tooling Goal

Provide a complete development experience for Pebble developers with IDE integration, debugging tools, and build system support.

Key Results

• Language Server Protocol (LSP) implementation:
• Syntax highlighting
• Auto-completion
• Go-to-definition
• Find references
• Inline error reporting
• Hover documentation
• Stable and reliable sourcemaps for debugging compiled contracts
• CLI improvements:
• Build and watch modes
• REPL for interactive development
• Blueprint generation for contract metadata

Estimated Effort

1.5 FTEs

Pebble Summary

• total resources estimated: 3.5 FTEs

Differentiation from Aiken

Pebble and Aiken serve different developer profiles and are complementary within the Cardano ecosystem, not competitive.

Dimension	Aiken	Pebble	Implication
Paradigm	Functional-first (Rust-inspired)	Imperative-first (TypeScript-inspired)	Different mental models for different developers
Target audience	Developers comfortable with FP	Web2/EVM developers	Expands total addressable developer pool
Syntax familiarity	Rust, Gleam	TypeScript, JavaScript, Solidity	Lower barrier for the 17M+ JS/TS developers globally
Learning curve	Requires FP fundamentals	Familiar imperative patterns	Faster onboarding for majority of developers

Why both matter

Cardano needs multiple on-ramps for developers:

• Developers with Rust/Haskell/FP experience gravitate toward Aiken
• Developers with JS/TS/Solidity experience will find Pebble more accessible
• Both compile to optimized UPLC; the choice is about developer preference, not runtime performance

By funding Pebble, the Treasury expands Cardano's developer funnel without fragmenting it.

Hard-fork maintenance

Main Objective
guarantee ecosystem stability

Upcoming Intra-Era Hard Fork Goal

Ensure all HLabs TypeScript libraries are updated and fully compatible with the upcoming hard fork, including Plutus V4 changes and new protocol parameters.

Key Results

Maintenance of the affected repositories to support new protocol features:

• cardano-ledger-ts: Collection of functions and classes defining the Cardano ledger data structures
• ouroboros-miniprotocols-ts: TypeScript implementation of the Ouroboros networking protocol
• plutus-machine: CEK machine implementation for UPLC evaluation
• uplc: TypeScript/JavaScript representation of UPLC

Estimated Effort

1.5 FTE

Hard-Fork Maintenance Summary

• total resources estimated: 1.5 FTE