Cometa.cpp: Cardano SDK for C++ with Full Conway Era Support

[Proposal setup] Proposal title

Please provide your proposal title

Cometa.cpp: Cardano SDK for C++ with Full Conway Era Support

[Proposal Summary] Budget Information

Enter the amount of funding you are requesting in ADA

60000

[Proposal Summary] Time

Please specify how many months you expect your project to last

6

[Proposal Summary] Translation Information

Please indicate if your proposal has been auto-translated

No

Original Language

en

[Proposal Summary] Problem Statement

What is the problem you want to solve?

No complete SDK exists for C++, preventing developers from building dApps or accessing Cardano features like transaction building, governance, and full Conway-era support.

[Proposal Summary] Supporting Documentation

Supporting links

• https://cometa.dev/
,
• https://github.com/Biglup/cardano-c

[Proposal Summary] Project Dependencies

Does your project have any dependencies on other organizations, technical or otherwise?

Yes

Describe any dependencies or write 'No dependencies'

https://github.com/Biglup/cardano-c

[Proposal Summary] Project Open Source

Will your project's outputs be fully open source?

Yes

License and Additional Information

The project will be fully open source, licensed under Apache 2.0. All code will be developed and maintained publicly on GitHub, ensuring transparency, community collaboration, and permissive reuse.

[Theme Selection] Theme

Please choose the most relevant theme and tag related to the outcomes of your proposal

Developer Tools

[Campaign Category] Category Questions

Mention your open source license and describe your open source license rationale.

We will use the Apache 2.0 license for this project. It’s a permissive open source license that allows broad usage, modification, and distribution, even in commercial projects, while protecting contributors through clear terms.

How do you make sure your source code is accessible to the public from project start, and people are informed?

All development will take place in a public GitHub repository, making the code accessible from day one. We’ll use version control, clear documentation, and issue tracking to ensure transparency and allow anyone to follow progress, contribute, or use the SDK.

How will you provide high quality documentation?

We’ll provide high-quality documentation by combining well-commented code with auto-generated API docs using Doxygen. The documentation will be published on Read the Docs, with clear usage guides, examples, and setup instructions. You can see an example of our documentation approach at cardano-c.readthedocs.io.

[Your Project and Solution] Solution

Please describe your proposed solution and how it addresses the problem

We propose to build Cometa.cpp, a complete Cardano SDK for C++, by creating language bindings for the libcardano-c library. This will give C++ developers direct access to Cardano’s key features, including transaction construction and Conway-era governance.

Cometa.cpp will expose a clean, idiomatic C++ API backed by a safe, MISRA-compliant C core. This lets us deliver full protocol support without re-implementing complex logic in C++. Developers will be able to construct, sign, and serialize transactions, handle native assets, and interact with on-chain governance, all from C++.

Today, C++ lacks a reliable SDK for Cardano. While other languages like JavaScript and Python are supported, the C++ ecosystem has been left behind, until now.

Our solution is a lightweight, well-documented, and actively maintained SDK tailored to C++. By building on libcardano-c, which already supports full Cardano transaction features up to the Conway era and was built specifically for this purpose, we ensure stability and correctness. libcardano-c is extensively tested (over 8,000 tests) and comes with robust documentation, providing a solid foundation for Cometa.cpp.

[Your Project and Solution] Impact

Please define the positive impact your project will have on the wider Cardano community

This project will expand access to Cardano by enabling C++ developers, many of whom have lacked a direct way to interact with the blockchain, to build dApps, tools, and integrations in a language they already use. By supporting full Conway-era functionality, Cometa.cpp lets developers handle governance, build transactions, derive addresses, and use other advanced features directly from C++.

The broader impact is a more inclusive and diverse developer ecosystem. With C++ widely used in systems programming, embedded devices, and high-performance applications, this project lowers the barrier for a new wave of developers to join the Cardano ecosystem. Over time, it will drive more community tools, broader platform adoption, and increased innovation across the network.

[Your Project and Solution] Capabilities & Feasibility

What is your capability to deliver your project with high levels of trust and accountability? How do you intend to validate if your approach is feasible?

Our team has a proven track record in delivering high-quality, low-level blockchain tooling in both C and TypeScript. We are the creators of libcardano-c, a robust, MISRA-compliant C library that implements full transaction-building capabilities for Cardano. Additionally, I am one of the core maintainers of the cardano-js-sdk and was responsible for developing the serialization and cryptography packages that serve as foundational components for other libraries and dApps across the Cardano ecosystem.

We follow open-source best practices, including public development on GitHub, continuous integration, automated testing, and comprehensive documentation to ensure transparency, accountability, and long-term maintainability.

To validate the feasibility of our approach, we will begin by building a working prototype that exposes the core transaction-building functionality through C++ bindings. This prototype will be tested using real-world scenarios such as constructing and signing transactions, submitting them to the blockchain, and interacting with governance features. If any protocol-specific challenges arise during binding generation, we will refine the C-level abstractions in libcardano-c to ensure clean integration and idiomatic usability within the C++ environment.

[Milestones] Project Milestones

Milestone Title

Binding Initial primitives and API Surface design

Milestone Outputs

• A working C++ binding layer to libcardano-c, enabling C++ code to call C functions
• Initial C++ module/namespace structure established (e.g., Cometa::Cardano) following idiomatic C++ conventions
• Binding of foundational primitives, including:
  • Address parsing and conversion
  • Cryptography functions (key generation, hashing, signature verification)
  • CBOR encode/decode utilities for raw data inspection
• Initial API surface documented, with clear conventions for naming, memory management (RAII), and error propagation (error codes/exceptions)
• Automated tests covering all exposed functions, verifying correctness and safe memory interaction
• README and developer setup instructions published on GitHub
• CI pipeline configured to build and run tests on major platforms (Linux/macOS/Windows)

Acceptance Criteria

• The C++ binding layer must allow stable, reproducible calls to a subset of libcardano-c functions.
• Core primitives (address parsing, cryptography, CBOR utilities) are exposed and callable from C++ without crashes or memory leaks.
• The namespace/module structure (e.g., Cometa::Cardano) is organized, documented, and consistent with idiomatic C++ practices.
• The API surface follows consistent naming conventions, with safe memory management (RAII) abstracted from users.
• All bound functions include automated tests validating correct input/output behavior and edge cases.
• The project builds and all tests pass across supported platforms.
• Documentation (README + API design doc) is clear and sufficient for new contributors to understand the structure and begin using the SDK.

Evidence of Completion

• All source code, including C++ bindings and namespaces/modules, is publicly available in the GitHub repository
• README with setup instructions, usage examples, and developer guidelines is published and up to date
• Binding documentation and API design notes are committed
• CI pipeline configuration and test results are visible in the repository
• Unit and integration tests for all exposed primitives are included

Delivery Month

2

Cost

20000

Progress

30 %

Milestone Title

Transaction Builder

Milestone Outputs

• Binding of all major transaction builder components from libcardano-c, full capabilities documented here: https://cardano-c.readthedocs.io/en/latest/api/transaction_builder/transaction_builder.html
• Implement a blockchain data provider (Blockfrost) with an extensible interface for additional providers
• Unit tests for all transaction builder bindings
• API documentation for all builder components

Acceptance Criteria

• The builder follows a clear and idiomatic C++ API style, with proper error propagation and memory management (RAII) abstracted away from the user
• All core builder functions are covered by integration tests and run successfully across supported platforms in CI
• The API is documented, and examples are included to demonstrate how to construct and serialize transactions using Cometa.cpp

Evidence of Completion

• All transaction builder bindings are published in the GitHub repository under the appropriate C++ namespace (e.g., Cometa::TransactionBuilder)
• Unit tests for the builder are passing
• The full API surface for transaction building is documented and committed to the repository
• CI logs confirm successful builds and test runs on all supported platforms

Delivery Month

4

Cost

25000

Progress

60 %

Milestone Title

Bug Fixes, Documentation, Packaging, and Release

Milestone Outputs

• Final bug fixes and cleanup of C++ bindings
• Complete and polished API documentation, including:
  • Descriptions of all namespaces, classes, methods, and expected inputs/outputs
  • Inline comments and usage notes
  • Developer guide and setup instructions for using the C++ SDK
• Example programs showing real-world usage (e.g., transaction creation, governance, Plutus scripts, minting, metadata)
• Packaged Cometa.cpp library ready for publication (via CMake)
• Public announcement on GitHub, Cardano Forum, and X
• Submission of the SDK entry to developers.cardano.org/tools for visibility

Acceptance Criteria

• API documentation is complete, accurate, and includes method descriptions, usage notes, and namespace/class overviews
• Developer guide clearly explains installation, setup, and basic usage of the SDK
• All example programs run without errors and cover key use cases: transaction creation, governance, Plutus scripts, minting, and metadata
• The Cometa.cpp package builds successfully and can be installed via CMake
• The SDK is published or tagged as a release and publicly accessible
• Announcements have been made on GitHub, the Cardano Forum, and X to notify the community
• The SDK is submitted for listing on developers.cardano.org/tools
• No major unresolved issues or regressions remain in the release

Evidence of Completion

• API documentation and developer guide are committed to the public GitHub repository
• Example programs are available under an /examples directory and verified to run successfully
• Public announcement posts are available on GitHub (release notes), the Cardano Forum, and X (links provided)
• A submission has been made to developers.cardano.org/tools, with listing status documented
• CI logs or GitHub Actions history confirm successful builds and tests across supported platforms (Linux, macOS, Windows)

Delivery Month

6

Cost

15000

Progress

100 %

[Final Pitch] Budget & Costs

Please provide a cost breakdown of the proposed work and resources

Milestone 1: Binding Initial Primitives and API Surface Design

Budget: 20,000 ADA

• Angel Castillo: 10,000 ADA
• Luis Daniel Bianchi Cordova: 10,000 ADA

Milestone 2: Transaction Builder

Budget: 25,000 ADA

• Angel Castillo: 10,500 ADA
• Luis Daniel Bianchi Cordova: 10, A00DA

Milestone 3: Bug Fixes, Documentation, Packaging, and Release

Budget: 15,000 ADA

• Angel Castillo: 7,500 ADA
• Luis Daniel Bianchi Cordova: 7,500 ADA

[Final Pitch] Value for Money

How does the cost of the project represent value for the Cardano ecosystem?

This project offers strong value to the Cardano ecosystem by making the platform accessible to C++ developers. For 60,000 ADA, we’re delivering a complete, open-source SDK that gives developers everything they need to build with Cardano from C++, including full support for Conway-era features.

The cost covers all phases of the work: binding generation, testing, documentation, packaging, and release. Because we’re building on top of libcardano-c, a well-tested, production-grade C library we’ve already developed, we can move quickly and keep costs efficient without cutting corners on quality.

With this SDK, C++ developers will be able to build dApps, tools, and integrations directly with the Cardano blockchain. It opens the door to new use cases and broader adoption, delivered by a small, experienced team.

In short, this is a high-impact, low-risk project that brings lasting value to the ecosystem at a fair cost.

[Required Acknowledgements] Consent & Confirmation

Terms and Conditions:

Yes