Cometa.lua: Cardano SDK for Lua with Full Conway Era Support

[Proposal setup] Proposal title

Please provide your proposal title

Cometa.lua: Cardano SDK for Lua 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 Lua, 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.lua, a complete Cardano SDK for Lua, by creating language bindings for the libcardano-c library. This will give Lua developers direct access to Cardano’s key features, including transaction construction and Conway-era governance.

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

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

Our solution is a lightweight, well-documented, and actively maintained SDK tailored to Lua. 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.lua.

[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 Lua developers, many of whom have been unable to interact with the blockchain, to build dApps, tools, and integrations using a language they already know. By supporting full Conway-era functionality, Cometa.lua allows developers to work with governance, build transactions, derive addresses, build dApps, and use other advanced features.

The broader impact is a more inclusive and diverse developer ecosystem. With Lua widely used in embedded systems, game development, and lightweight scripting, this project lowers the barrier to entry for a new wave of developers to join the Cardano ecosystem. In the long term, it will lead to more community-driven 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 personally 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 Ruby 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 Ruby environment.

[Milestones] Project Milestones

Milestone Title

Binding Initial primitives and API Surface design

Milestone Outputs

• A working Lua FFI bridge to libcardano-c, enabling Lua to call C functions
• Initial Lua module structure established (e.g., Cometa.Cardano) following idiomatic Lua 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 handling, and error propagation
• Automated tests covering all exposed functions, verifying correctness and safe memory interaction
• README and developer setup instructions published on GitHub
• CI pipeline configured to run tests on major platforms (Linux/macOS/Windows)

Acceptance Criteria

• The Lua FFI bridge must allow stable and reproducible calls to a subset of libcardano-c functions.
• Core primitives (address parsing, cryptography, and CBOR utilities) are exposed and callable from Lua without crashes or memory leaks.
• The module structure (Cometa.Cardano) is organized, documented, and consistent with idiomatic Lua practices.
• The API surface follows consistent naming conventions, and memory management is abstracted safely.
• All bound functions include automated tests validating correct input/output behavior.
• The project builds and passes all tests.
• 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 FFI bindings and Lua 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 committed
• CI pipeline configuration and test results visible in the repository
• Unit and integration tests for all exposed primitives included

Delivery Month

2

Cost

20000

Progress

30 %

Milestone Title

Transaction Builder

Milestone Outputs

• Binding of all major transaction builder components from libcardano-c, you can see all the capabilities of the libcardano-c here https://cardano-c.readthedocs.io/en/latest/api/transaction_builder/transaction_builder.html
• Implement a blockchain data provider (blockfrost). These can be extended in the future.
• Unit tests for the transaction builder bindings.
• API documentation for all builder components.

Acceptance Criteria

• The builder follows a clear and idiomatic Lua API style, with proper error propagation and memory handling 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.lua.

Evidence of Completion

• All transaction builder bindings are published in the GitHub repository under the appropriate Lua module (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 confirming 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 Lua bindings
• Complete and polished API documentation, including:
  • Descriptions of all modules, methods, and expected inputs/outputs
  • Inline comments and usage notes
  • Developer guide and setup instructions for using the Lua SDK
• Example scripts showing real-world usage (e.g., transaction creation, governance, Plutus scripts, minting, metadata)
• Packaged LuaRocks module (cometa.lua) ready for publication on LuaRocks
• 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 module overviews
• Developer guide clearly explains installation, setup, and basic usage of the SDK
• All example scripts run without errors and cover key use cases: transaction creation, governance, Plutus scripts, minting, and metadata
• The LuaRocks package (cometa.lua) builds successfully and can be installed via LuaRocks
• 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 scripts are available under an /examples directory and verified to run successfully
• The packaged LuaRocks module (cometa.lua) is published on LuaRocks.org or included in a tagged GitHub release
• 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 Lua developers. For 60,000 ADA, we’re delivering a complete, open-source SDK that gives developers everything they need to build with Cardano from Lua, 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, Lua 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