Product


# Introduction

## What is Ogre?

> Ogre is a **metacompiler** that analyzes source code to create the best runtime environment for it.

Differently from traditional compilers, Ogre has AI at its core and thus enables users to generate an entire execution environment, instead of only executable files, from input source code.

In essence, for each code base it is presented with, Ogre tries to answer the question: which packages/libraries need to be installed so the code runs flawlessly in the host system? And it does it with one command/click.

Ogre was designed to:

- Increase code usability by eliminating the need for developers to figure out and install dependencies manually, especially when working with third-party and/or poorly-documented code bases.
- Help CTOs and engineering managers maximize the value of R&D code by guaranteeing that research code will be runnable out-of-the-box anywhere.
- Amplify the performance of engineering teams by providing them with DevOps power, reducing their dependency on cumbersome processess (e.g. back-and-forth with DevOps team) that slow down product iteration.

The product comes in two flavors: a command-line interface (CLI), easy to be used from any terminal, and a Chrome browser extension, very handy when navigating GitHub and GitLab web pages. We also offer the Ogre box, a server targeted at enterprises whose sensitive data can't be stored in the cloud.

Ogre comes with a data platform that helps teams track key metrics for each environment, shedding a light on the actual relevance of a code base to the company's business performance.

## Why build this

In our experience as entrepreneurs and consultants to a handful of tech companies, we have witnessed engineering teams struggling to run code out-of-the-box in different machines and environments. In fact, every single client of ours (mainly AI companies) has this problem.

There is a lot of unusable code piling up in private and public repositories. Take for example GitHub: with over 330M repositories, it enables access to usable and dependable software as well as stale, undocumented, difficult-to-run code. In the last few years, GitHub (and similar platforms) has slowly become a dumpster where a lot of code goes to die. That code may remain untouched for years, and as a consequence, companies waste ideas and developer-hours (nobody has the patience and/or time to figure out what is necessary to run the code), while frictions among developers increase -- they can't immediately iterate on each other's work.

> This is a waste of innovation: we are letting many good, potentially profitable, ideas (code) to die because we don't have the time, tools, and the right incentives to continue exploring them.

This can't be solved by CI/CDs, README files, Dockerfiles: it is naive to think that all developers will get out of their confort zone to learn the devops skills necessary to guarantee code reproducibility (I have seen many teams fail miserably) -- plus, nobody is rewarded for writing a flawless documentation. This is specially true in AI development, where innovation published by researchers lacks the proper pipeline to be deployed anywhere, slowing down their spread.

At Ogre.run, we envision a solution for this by reimagining the role of code compilers in a world where AI is part of any product infrastructure (particularly generative AI). By offering developers a metacompiler that generates the perfect environment for a code base, Ogre can unlock the potential of many ideas to break into mainstream.

## Simplifying application packaging and deployment

As source code becomes a commodity easily accessible by anyone (for example, by searching on GitHub or generating functional blocks of code with OpenAI tools), **the main development roadblocks now lie in the deployment infrastructure, i.e., the underlying software and hardware where that source code is supposed to run.**

With so many options — from personal computers running single ARM chips to servers in the cloud with thousands of GPUs — **developers spend a great chunk of their time** considering what is necessary to make their product run in their client’s infrastructure. Here are a few questions they keep cycling through: Can we leverage GPUs? Do they require a specific linux kernel? What is the CPU architecture?

>Ogre was built to remove these questions from the product critical path. Developers just need to focus on their code and Ogre will create a functional environment that works out of the box in the target host system.

Additionally, for the most part, **sites like GitHub have become a place to dump source code, lacking organization and consistency**. Who hasn't tried to run code out of a repository and was faced with some sort of inconsistency of packages/libraries? This is beyond a nuisance — it is a major problem that hinders the execution of product roadmaps and increases project costs.


# What is unique about Ogre?

## Competition

The main competitors can be divided into three groups of tools, each made by different players:

1. Traditional DevOps tools like Docker, Conda, Poetry, CI/CDs (e.g. GitLab, Jenkins, Dagger)
2. AI-driven coding copilots such as Microsoft Copilot, GitHub Copilot, OpenAI APIs
3. Standard compilation frameworks such as GCC, clang (LLVM), Intel, IBM

As applications get more and more complex, developers tend to mix and match several of those tools in the same pipeline. We've seen this in many teams and identified the following unsolved issues that hinder development progress:

- Many points of failure: to run a code base, one needs to orchestrate multiple different tools. This increases the number of potential points of failure when deploying.

- Difficult to assemble performance data: the many points of failure make it even more difficult to adopt a data-driven development approach that measures the effective impact of a code base to the company's ROI.

- Knowledge fragmentation: most developers are not proficient in all the tools in the pipeline, preventing them from fully own a project from inception to production.

- Counter-productive team communication: to overcome knowledge fragmentation, team members need to increase internal communication, which then increases context-switch, resulting in overall team-performance degradation and slowing down delivery.

These issues combined result in a negative impact on business outcome and increase in frustration of executives who struggle to justify their investiment in R&D, especially in AI. And existing tools have not being able to fix that.

At Ogre.run, we see this as a major problem for companies moving forward, as their revenue becomes more and more dependent on their code-development teams' performance. Our assumption is that by offering a metacompiler such as Ogre, with AI at its core, those companies can remove the unlock a new level of performance and increase their ROI.

Ogre's scope goes beyond the narrow vision of optimizing code speed. In fact, Ogre prioritizes developer speed so they can get stuff out of the door fast.


## How is it different from Docker and CI/CD pipelines?

Container engines like Docker and CI/CD pipelines are great tools if and only if you know how to use them properly. **They require DevOps skills that most developers don’t have (and don't have the time to learn). This way, development teams need to rely on extra management processes** to synchronize with DevOps specialists and guarantee reproducibility, slowing down prototype development. 

>Ogre aims to reduce dependency on cumbersome processes, eliminating layers of bureaucracy, speeding up development, and freeing AI engineering teams to do what they are good at: bringing technology to functional prototypes.

That said, Ogre is not meant to be a substitute for Docker or CI/CDs. It plays nicely with those tools and can actually improve the way they are currently used in your development pipeline.

## How is it different from GitHub Copilot and OpenAI’s ChatGPT?

At time of writing, [GitHub Copilot](https://github.com/features/copilot) and [OpenAI's ChatGPT](https://chat.openai.com/) -- both subsidiaries of Microsoft -- are the two most popular generative-AI tools for assisted code development. While their performance for code generation is impressive, **their product philosophy is restricted to code correctness, i.e., they do not take into consideration the environment** (OS, hardware) where that code is supposed to be executed -- which, as previously stablished, is the main roadblock in code development these days.

>In the real world, code correctness does not guarantee it will run properly -- the user still has to spend precious development time adapting/optimizing that code to the specific constraints of the target infrastructure. That's where Ogre focus its efforts, making sure that your code runs regardless of the underlying computing system.

For that reason, we at Ogre.run don't see Copilot and ChatGPT as competitors to our products. In fact, we can leverage them inside our products via APIs, if need be. Even as Copilot and ChatGPT mature and add new features, e.g., [ChatGPT's new code interpreter](https://openai.com/blog/chatgpt-plugins#code-interpreter), Ogre.run's focus on the enterprise market (more below) allows it to differentiate itself from those tools -- **It can cater to the specific needs of enterprise clients, who will never store their precious IP in platforms like GitHub and risk them to be leaked due the its use in training Microsoft's LLMs.**

# Our vision

## Ogre as a source-code building framework

Compilers and source-code building frameworks are cornerstones of code development. They take a set of files (the source code) and a list of instructions (e.g. Makefile), and return a set of executable files that are tuned for the target computer (architecture) specified in the list of instructions.

A metacompiler takes the core idea of compilers (i.e. take a source code as input and return an executable file) and generalizes it to include entire runtime environments as the output. This way, differently from traditional compilers, one can always run the output (the runtime environment) in any computational system.

> The long-term vision for Ogre is to become a one-stop solution to convert, with the click of a button, a code base into a functional, executable system, without manual work.

By framing Ogre as a metacompiler, we can integrate it with multiple tools already familiar to millions of developers, e.g., [GCC](https://gcc.gnu.org/), [LLVM](https://llvm.org/), [Bazel](https://bazel.build/), leveraging them to do the compilation to executable files while using Ogre's core technology (details below) to build the runtime environment. It can even be integrated to fresh programming languages such as [Mojo](https://www.modular.com/mojo), designed to provide Python users with access bare-metal capabilties.

Ogre is the tool that ties everything together when it comes to production-driven development.

## Using AI agents to simplify development flow

To scale performance and enforce the simplest possible development flow, Ogre is taking advantage from the recent multiplication of generative-AI tools. **Its core technology is based on a set of custom large-language models (LLMs)** that are specialized to understand source code and their graph of dependencies (operating-system, hardware, and software libraries).

Each model is fine-tuned from foundational LLMs made available by the AI community (and with a permissive license that allows their use in commercial products). Currently, we are leveraging [OpenAI’s GPT-4](https://openai.com/research/gpt-4) and [Falcon 7B](https://huggingface.co/tiiuae/falcon-7b) inside the product. We also use [Meta's LLAMA-based models](https://ai.facebook.com/blog/large-language-model-llama-meta-ai/) for research purposes only.

Creating our own LLM-based AI agents enables Ogre.run to deliver more DevOps value to clients while using less resources than traditional solutions (e.g. dedicated teams of DevOps -- or AIOps -- engineers). Maximizing developer's performance and reducing context switching is the secret to successful product design and deployment.


What is Ogre?

Tutorials

The CLI enables the user to customize how ogre builds and deploys the coding environment. It enables the user to:
Modify specific deployment parameters that are not accessible from the extension
Deploy local projects, i.e., source code stored in a local folder, directly in the Ogre.run cloud. This is very handy for professionals who want to expose their project without the need to create a repository on GitHub or GitLab.

### Installation

1. Generate a token for your organization in the Ogre.run page.
2. Install the Ogre CLI with python pip: 
`pip install https://install.ogre.run/ogre_run-0.8.0-py3-none-any.whl`
This command will prompt you to provide a user name and a password (provided by email).
3. To check if everything was successfully installed, type
`ogre --help`

### Create a config file

You can modify the default Ogre parameters by creating a config file. To generate one based off a template, go inside the folder containing the Python code you want to run, and type

`
ogre --config
`

The config file consists of several parameters that control the behavior of Ogre.run and how it builds the environment.


```
path: .
web: False
jupyter: True
jupyter_password: ogre123
jupyter_port: "8001"
mount: True
api_url: https://dev-cloud.ogre.run
api_token: <OGRE_TOKEN>
docker:
 company: ogarantia
 version: 0.1.0
 baseimage: ogarantia/ogre:base-ubuntu22.04-<PLATFORM>
 device: cpu
 container_repo: ghcr.io
 project_volume_path: /opt
 cmd: bash
 ttyd: ttyd
 ttyd_version: 1.6.3
 ttyd_url: https://github.com/tsl0922/ttyd/releases/download/
 ttyd_port: 6007
 ogre_dir: ogre_dir
 requirements_format: freeze
 expose_ports: 8888
 no_cache: True
```

where you should substitute &lt;OGRE_TOKEN&gt; by the token created in the ogre.run website, and &lt;PLATFORM&gt; by either amd64 (e.g. Intel CPUs) or arm64 (e.g. Mac).
 
Using the config file you can: 
1. Choose a different port to deploy the environment (try jupyter_port: 8081 for example); However, if the desired port is already taken, Ogre.run will automatically choose a free port.
2. Define which container ports you want to expose to the host (this comes in handy if your application runs on a specific port). If you need to expose more than one port, separate then by commas, e.g., expose_ports: 8081, 8090. If you don't want/need to expose container ports, set it equal to zero, i.e., expose_ports: 0;
3. Choose a different baseimage on top of which your project image will be built. Try for example pytorch/pytorch:latest to build your environment based on the latest pytorch version.
Now you are ready to deploy your environment using the CLI.

### Metacompile a code base from the command line
Go inside the folder containing the python code you want to metacompile. 
> **IMPORTANT:** Ogre is currently limited to code bases that contain at least a README file with instructions to run the code. We are working to remove that limitation and enable Ogre to work without the need for a README file.

Type the command 
`ogre –-yaml_config ogre.yml` 
This command will send a request to the Ogre Cloud, which will then run the metacompilation of your code base and send back a file with instructions on how to build the optimal environment to run the code in your local system.
 
Once the environment is done being built, you can access it by visiting the address returned by the command `ogre --info` for example, for the following output
 
 ```
 >>>Info about ogre containers running in the local system.
ogre-ogarantia-<YOUR_PROJECT_NAME>-jupyter 0.0.0.0:8001->8001/tcp
 ```
 
you should access the address 0.0.0.0:8001 on a web browser. 

If you prefer to expose your code base to everybody, you have the option to use the Ogre cloud. Use the following sequence of commands to package, publish, and start the service online.
1. Package code.
`ogre --package`
2. Publish code to the cloud (this step just uploads it; no service is started).
`ogre --publish`
3. Start the Ogre service. Your environment will be built remotely (in the Ogre Cloud) according to the parameters in your ogre.yml file.
`ogre --service_up`
4. Once finished building, you will be able to access the jupyterlab environment from the browser, the same way as when using the extension.
Finally, to stop the service just do
`ogre --service_down`



 >**Congratulations!** You have successfully learned how to use Ogre.run CLI.
 >If you have any further questions or need assistance, feel free to reach out to our support team.

Using the CLI


## Step 1: Create your account

1. Head to _**[www.ogre.run/auth/sign-up](https://www.ogre.run/auth/sign-up)**_ and create your account.
2. Select the name of your organization and click on the **Create** button.
3. You will be redirected to the dashboard of your organization.

## Step 2: Create your token
![Tokens Page](/assets/images/posts/tokens.png "Getting Started")
1. Go to the _**[Tokens Tab](https://www.ogre.run/tokens)**_.
2. Click on the **New Token** button.
3. **Copy** the Token and **save it** somewhere safe. You will need it in **Step 4**.
4. You can optionally add a description to your token.
5. Click on **Create Token**.

> **IMPORTANT**: From this point on, you can **jump into the CLI**, if you wish. Follow this link to set it up: _**[https://www.ogre.run/blog/tutorials/CLI](https://www.ogre.run/blog/tutorials/CLI)**_

## Step 3: Install the Chrome extension
![Chrome Store](/assets/images/posts/store.png "Getting Started")
1. Head to _**[Chrome Web Store: Ogre.run](https://chrome.google.com/webstore/detail/mpfngkffdahoijgoeggoomjfipkjakcc)**_ and install the extension.
2. Go to a _public_ **GitHub** or **GitLab** repository.
3. You should see the _**Ogre**_ button as shown below, if not, reload the page.

## Step 4: Add the configuration
![Extension settings](/assets/images/posts/extension-settings.png "Getting Started")
1. Click on the **Ogre** button. You should be in the **Settings** tab.
2. Click on **Edit**
3. **Paste** the token you created in _Step 2_.
4. The server address should be _cloud.ogre.run_ by default. Don't change it unless we give you a custom address.
5. Click on **Save**.

## Step 5: Deploy!
![Extension ogre](/assets/images/posts/extension-ogre.png "Getting Started")
1. Go to the **Ogre** tab.
2. Click on **Generate**.
3. You should see message below the button in the image above.
4. Click on the link, and you're good to go!


 >**Congratulations!** You have successfully learned how to use Ogre.run web platform and the Chrome extension.
 >Now you can easily share and deploy your code with just a few simple steps.
 >If you have any further questions or need assistance, feel free to reach out to our support team.


Blog

Tutorials, Guides and Updates from the MakerKit team

What is Ogre?

Using the CLI

Deploying your first environment