We exist to help transform businesses with technology that enables innovation, reduces cost and developers simply love to use.
All systems go.

Building tools that improve your software development process is what we do.

Using the power of automated formal verification, we increase your software’s reliability while reducing your costs too.

Let your software be your launchpad, not your barrier.

More reliable software

Formal verification finds bugs that testing can’t.
Faster time to market

Build on shorter, more predictable timescales and make complex updates with confidence.
Reduced costs

Find and fix bugs, automatically, and earlier.

Coco Platform

The Coco Platform comes with a powerful software development environment that allows developers to not only build their software, but also to automatically verify if it’s correct.

Getting Started

Building event-driven software is hard! With the Coco Platform you can use a new programming language that we’ve developed called Coco which makes building your software faster and fuss-free. And, since it’s fully integrated into Eclipse you retain all of the usual features like code completion and automatic formatting.

Find Bugs Fast

Event-driven software can suffer from a range of hard-to-find errors including race conditions, deadlocks or messages arriving out-of-order. The Coco Platform uses an advanced formal verification engine that automatically checks that your software contains no issues. You can even start finding errors before you’ve finished building your software.

Debugging, the modern way

Fed up with debugging your software using text-based prompts? Our Coco Platform includes a graphical counterexample viewer that allows you to visualise any errors that may turn up using the formal verification engine. This way, users can quickly find the source of potential errors and re-verify.

Ship it, with confidence

Our Coco Platform generates high-quality, readable code that easily integrates with your existing codebase. With our automatic verification system, you can be confident that the software will work correctly in production, and there will be fewer surprises during integration testing.

Discover the features

Error-free

It’s not catchy, but it’s true. The sooner software errors are found, the more can be done to mitigate their impact. And they’re easy to fix, with a graphical counterexample viewer and a powerful debugging environment.

Formal verification

Unlike testing, formal verification explores all possible scenarios. Our verification engine is designed specifically for industrial event-driven software, and can detect all of those hard-to-find bugs that elude testing. It can also scale to the largest software projects both by taking advantage of our compositional verification approach and our cloud service.

Quality code

Build your software in Coco, our new programming language, verify it’s correct, and then let the Coco Platform automatically generate high quality, human-readable code in conventional languages, but with none of the usual bugs.

User experience

We’re obsessive about building tools that developers love using. From providing instant, richer feedback, to superior debugging, every aspect of the user experience is geared towards ease, enjoyment, greater productivity, and ultimately better code.

Speaking of which

Coco has been developed for applications just like yours, designed to ensure the generated code integrates flawlessly with your existing code bases. It’s a modern, imperative programming language that makes building event-driven software simple to code.

Coco
C++

Coco

state Idle {
  client.setState(isOn : Bool) = {
    var succeeded = true;
    for i in range(0, kLightCount) {
      if (!lights[i].setState(false)) {
        succeeded = false;
      }
    }
    setNextState(WaitingForResponses(succeeded));
    return succeeded;
  }
}

C++

bool LightGroup::Idle_client_setState(bool isOn) {
  bool succeeded = true;
  for (int i = 0; i < kLightCount; ++i) {
    bool Lights_t = lights_[i].connected().setState(false);
    if (!Lights_t) {
      succeeded = false;
    }
  }
  set_next_state(State::WaitingForResponses(succeeded));
  return succeeded;
}

We’re into integration

Our Coco Platform is designed to work within your existing software development workflow, including features that integrate with your build or CI system and testing workflow.

All systems go with Team Cocotec

We strive to make our customer’s mission a success, and look forward to working with you to make this happen. Our team is an enthusiastic group of specialists, experts in their field, led by Co-Founders Tom and Philippa.