Please describe your proposed solution.

Getting started with writing smart contracts on Cardano with Plutus is hard because of the dependencies baggage. It can easily take days for developers to have a working and productive system setup for Plutus smart contract development. It does not have to be that way. Look how easy it is to get started on Ethereum.

There are several awesome people, projects and proposals on Cardano trying to address this problem by offering easy infrastructure setup for Cardano node, vscode like editors, and tools. This is great to see. However, we believe we can do better. How about no setup at all? All you need is a browser and a good internet. How does that sound? As a developer, if you can start writing smart contracts directly on the browser, compile the contract by clicking a button and deploy/interact with your contract by directly interacting with your favourite wallet. Wouldn't that be awesome? We believe so.

KuberIDE is our solution to the problem. It is a fully browser based IDE for a complete Plutus smart contracts development experience. No setup required. Just writing Plutus contracts, compile them on demand with a button and create transactions, sign them, interact with your favorite wallet, all within the browser. It may sound like selling a dream, it is not. In fact, KuberIDE is already live and you can start using it for free here: <https://kuberide.com>

This proposal is here to ask for your support so we can develop KuberIDE v2.0 with the features that further enhances the developer experience on Cardano. Here is a short summary.

1. Faster compiler. Right now it take a few seconds (2-5 seconds). We can reduce it further.
2. Support for writing and running contract tests, showing coverage.
3. More examples and documentation
4. Better syntax highlighting and navigation
5. Support git repo integration for code management
6. Common issues and vulnerabilities detection
7. Audit checklist for your contract about what you need to prepare to submit for auditing your contract code.

Here is how the IDE looks like:

How does your proposed solution address the challenge and what benefits will this bring to the Cardano ecosystem?

The proposed solution lies under 'Plutus and IELE tools & software' proposal type based on the challenge brief. The proposal is essentially an IDE for Plutus smart contract development that improve the lives of smart contract developers releasing them from the hassle of maintaining the infrastructure themselves.

In the last two years, we have trained several developers on Plutus/Haskell and we know the pain. We know first hand, getting somebody trained and make them productive on Cardano smart contract development is expensive. Having done smart contracts development on EVM chains ourselves before, we can feel how big the gap is. So, it was in our interest to make the process of training efficient and getting developers productive as quickly as possible. Exactly for that, we have made a significat personal investment to get KuberIDE to what it is now. With KuberIDE, it has become so much productive to get a developer onboard. We use the IDE for our own contract development and testing and constantly improve with perf improvement and bug fixes.

We believe so many Cardano developers can benefit from KuberIDE. Especially new developers just trying to join the journey of developing smart contracts on Cardano. KuberIDE hides the complexity of the infrastructure and lets developers focus on what is important - contract code.

We have participated and helped organize Hackathons where we have majority of the participants struggle at the first step of getting the environment setup. At the end they get a feeling of not-so-productive hackathons. That is sad. Imagine now organizing Hackathon with KuberIDE. The participants can get directly into writing smart contracts, compile the code with a button and deploy their contracts by interacting with the wallet. They will get a sense of achievement at the end of the session. Wouldn't that improve the Cardano developers experience?

Quantifying the impact, we would consider KuberIDE a success if we can improve the developer experience of 100 developers in a year, realistically speaking.

How do you intend to measure the success of your project?

The measure of the success is adoption of the IDE by the broader developer community on Cardano. Knowing how many developers are building on Cardano using KuberIDE on a regular basis would be main metric to measure.

Here is a list of metrics we intend to measure.

1. Number of Plutus developers using the project: Daily, Monthly, All Time
2. Number of new developers onboarded every month
3. Developer surveys
4. Number of feature reports from developers
5. Number of bug reports from developers and sentry (automated)

Please describe your plans to share the outputs and results of your project?

Our proposal here is to deliver KuberIDE 2.0 with the features listed in the proposal incrementally, one feature at a time. Therefore, with each feature complete, we plan to do a minor release and share with the community. Then the broader community can be the judge of the development and the delivery. This will be reflected by the results.

Regarding results, we plan to publish the above mentioned metrics on our website (<https://kuberide.com>) so it is realtime and visible to anybody at any time.

For the developer surveys which are qualitative, we'll share the results on a blog and hopefully on Catalyst Town Hall if given a chance.

What is your capability to deliver your project with high levels of trust and accountability?

In terms of capability, we believe we're the best team to deliver the project for these reasons:

1. We're the same team who built the first version of KuberIDE which is already a complex system under the hood. We built the IDE based on our own experience working on Haskell and writing Plutus contracts. So, we know the problem we're solving first hand.
2. We're a trusted team who have worked (and is still working with IOG) on different projects and assignments.
3. Our team consists of experienced Haskell/Plutus developers, engineers and devops to deliver a great working software product.

To demonstrate that we can manage the funds properly, we plan to show how employ the agile software development methodology as we have always done ourselves internally.

1. Build in sprints: We follow a short sprint cycle of 1 week where we ship at the end of sprint. The cycle goes as plan for the sprint, work on the sprint tickets, sprint review and deploy at the end of sprint.
2. Release at the end of the sprint: Progress can be made if we maintain the cadence of shipping something usable at the end of the sprint.
3. Get feedback from the users either directly on GitHub or via Discord and incorporate that on the sprint planning.
4. Welcome the interested communities members to join our sprint review meetings and the release.

What are the main goals for the project and how will you validate if your approach is feasible?

The main goals of the project are:

1. Make the online Plutus/Haskell compiler more scalable and reliable and faster.
2. Add support for writing and running contract tests right on the IDE and showing coverage whereever possible.
3. Add more documentation and examples of common smart contracts use-cases.
4. Improve syntax highlighting and navigation.
5. Support git repo integration for the smart contract code management on the IDE, similar to Remix IDE for Ethereum.
6. Add common issues and vulnerabilities detection on the contract.
7. Provide basic audit readiness checklist for Plutus contract to make the auditing easier for the contract developer.

Regarding the validation if the approach is feasible, we have already done research on them and have a good idea on how we can implement them.

Most of the goals are technical features which are based on the feedback from the users of the IDE. Based on our current research, knowledge and experience, there are no known blockers to achieve the above mentioned goals so we find them feasible for this project.

Please provide a detailed breakdown of your project’s milestones and each of the main tasks or activities to reach the milestone plus the expected timeline for the delivery.

Milestone 1: Core Compiler Improvements

Key tasks:

• Improve resource allocation/de-allocation for the compiler.
• Improve compiler crash and recovery on failure.
• Improve the startup time for the compiler so users can compile their Plutus code almost immediately.

Timeline: 2 months

Projected costs: 117,073 Ada

Implementation Plan:

• Benchmark the current limits of the compiler (max compilers can we concurrently support at a time)
• Implement compiler REPL to speed up the compile time replacing single execution container.
• Implement crash and failure detection mechanism
• Implement sentry

Milestone 2: Contract Tests and Docs

Key tasks:

• Add editor support to write contract tests
• Add compiler support to run contract tests
• Add documentation and examples

Timeline: 2 months

Projected costs: 117,073 Ada

Implementation Plan:

• Update the base compiler image to be able to run contract tests and return the test results
• Add coverage support where possible.
• Update the editor to write tests
• Add syntax highlighting for tests
• Add documentation and examples of common use case

Milestone 3: Better source code management

Key tasks:

• Add git repo integration on the IDE for source code management

Timeline: 2 months

Projected costs: 78,049 Ada

Implementation Plan

• Add javascript git support on the IDE
• Add sync mechanism to keep the code up-to-date between the IDE and the remote repo.
• Address git conflicts when there are inconsistent states of the source code files.
• Add sample repos with example contracts

Milestone 4: Audit readiness

Key tasks:

• Add common issues and vulnerabilities detection on the contract
• Prepare basic audit readiness checklist for Plutus contract

Timeline: 2 months

Projected costs: 78,049 Ada

Implementation Plan

• Implement code analysers for common issues/pattern detection.
• Try out tracers for execution flow
• Use AI to train on known vulnerabilities and issues. Add consent request mechanism for it.
• Prepare the audit readiness checklist template
• Customize the audit readiness checklist based on the user contract.

Please describe the deliverables, outputs and intended outcomes of each milestone.

Milestone 1: Core Compiler Improvements

Deliverables:

• Deployment of the completed feature on kuberide.com

Output:

• Benchmark the current limits of the compiler (max compilers can we concurrently support at a time)
• Implemented compiler REPL to speed up the compile time replacing single execution container.
• Implemented crash and failure detection mechanism
• Implemented sentry

Intended outcomes:

• Compiler is fast and reliable
• Compiler scales with number of users

Milestone 2: Contract Tests and Docs

Deliverables:

• Deployment of the completed feature on kuberide.com

Output:

• Updated the base compiler image to be able to run contract tests and return the test results
• Added coverage support where possible.
• Updated the editor to write tests
• Added syntax highlighting for tests
• Added documentation and examples of common use case

Intended Outcome:

• Users can write and run contract tests on the IDE

Milestone 3: Better source code management

Deliverables:

• Deployment of the completed feature on kuberide.com

Output:

• Added javascript git support on the IDE
• Added sync mechanism to keep the code up-to-date between the IDE and the remote repo.
• Addressed git conflicts when there are inconsistent states of the source code files.
• Added sample repos with example contracts

Intended Outcome:

• Users can import git repo on the IDE
• Users can sync git repo on remote like GitHub

Milestone 4: Audit readiness

Deliverables:

• Deployment of the completed feature on kuberide.com

Output:

• Implemented code analysers for common pattern detections.
• Tried tracers for execution flow
• Used AI to train on known vulerabilities and issues. Add consent request mechanism for it.
• Prepared the audit readiness checklist template
• Customized the audit readiness checklist based on the user contract.

Intended Outcome:

• Users can check the common issues and vulnerabilities on their contract
• Users can see a list of checklist specific to their contract to prepare for audit of the contract.

Please provide a detailed budget breakdown of the proposed work and resources.

Milestone 1: Core compiler improvements

Resources: 2 backend developer, 1 devops/reliability engineer

Timeline: 2 months

Budget: 117,073 Ada

Milestone 2: Contract Tests

Resources: 2 backend developer, 1 frontend developer

Timeline: 2 months

Budget: 117,073 Ada

Milestone 3: Better source code management

Resources: 1 backend developer, 2 frontend developer

Timeline: 2 months

Budget: 78,049 Ada

Milestone 4: Audit readiness

Resources: 2 backend developer, 1 frontend developer

Timeline: 2 months

Budget: 78,049 Ada

Project Management (1)

Timeline: 8 months

Budget: 39,024 Ada

Marketing & community engagement (1)

Timeline: 8 months

Budget: 39,024 Ada

Total budget: 468,292 Ada

Who is in the project team and what are their roles?

Sandip Pandey, Project Manager

Sudip Bhattarai, Lead engineer

Nabin Pokharel, Plutus/backend developer

Kushal Pokharel, Plutus/backend developer

Simran KC, Plutus/backend developer

Bibishan Pandey, frontend developer

Ankit Sapkota, frontend developer

Moni Dahal, Marketing and Promotion

This is the same team that built the current version of KuberIDE.

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

First and foremost, we have been doing the development of the IDE ourselves for over a year without any external investment. This is a significant commitment and investment from our side. We believe that investing in developers productivity will pay off over time. Preventing the waste of developers time struggling to get the infrastructure working in itself is a very satisfying feeling. Hope the community agrees with me.

While we made the investment building the first version of the IDE which is available for free for everybody to use, we would like your support in building the next release which will be better, faster and scalable.

The costs are reflective of the time required to build the features mentioned in this proposal.