codemp

Collaborative to the core

We want to streamline and simplify remote software development.

Document editing has been collaborative for years now, so why is code lagging behind?

We offer a real remote collaborative experience, with all the expressiveness your editor of choice can provide.

Great software is made by great teams. It's important to allow them to perform from whatever distance.

Collaboration doesn't mean just synchronization.

Don't compromise on your editor

With codemp you no longer need to conform to your colleague's choice of editor to cooperate.

Simply install the plugin in your IDE of choice, and work together with others on any compatible system!

We natively support a growing number of text editors and IDEs, and offer developers tooling to easily integrate new ones.

Extensible by design

codemp is Open Source Software: it strives to be a full ecosystem for collaborative remote development.

We ship a native Rust library, as well as a growing list of ready-to-use bindings in many other languages.

Can't find a plugin for your editor? Integrating codemp with your IDE is easy.

Rust

JavaScript

Java

Python

Lua

use codemp::api::Controller; // needed for send/recv trait methods

// connect first, api.code.mp is managed by hexed.technology
let client = codemp::Client::connect(codemp::api::Config {
	username: "mail@example.net", password: "dont-use-this-password", ..Default::default()
}).await?;

// create and join a workspace
client.create_workspace("some-workspace").await?;
let workspace = client.join_workspace("some-workspace").await?;

// create a new buffer in this workspace and attach to it
workspace.create("/my/file.txt").await?;
let buffer = workspace.attach("/my/file.txt").await?;

// write `hello!` at the beginning of this buffer
buffer.send(codemp::api::TextChange {
	start: 0, end: 0, content: "hello!".to_string(),
	hash: None, // optional, used for error detection
}).await?;

// wait for cursor movements
loop {
	let event = workspace.cursor().recv().await?;
	println!("user {event.user} moved on buffer {event.buffer}");
}
import * as codemp from codemp;

// connect first, api.code.mp is managed by hexed.technology
let client = await codemp.connect({
	username: "mail@example.net", password: "dont-use-this-password"
});

// create and join a workspace
await client.create_workspace("some-workspace");
let workspace = await client.join_workspace("some-workspace");

// create a new buffer in this workspace and attach to it
await workspace.create("/my/file.txt");
let buffer = await workspace.attach("/my/file.txt");

// write `hello!` at the beginning of this buffer
await buffer.send({
	start: 0, end: 0,
	content: "hello!",
});

// wait for cursor movements
while (true) {
	let event = await workspace.cursor().recv();
	console.log(`user ${event.user} moved on buffer ${event.buffer}`);
}
import mp.code.*;

// connect first, api.code.mp is managed by hexed.technology
Client client = Client.connect(
	new data.Config("mail@example.net", "dont-use-this-password")
);

// create and join a workspace
client.createWorkspace("some-workspace");
Workspace workspace = client.joinWorkspace("some-workspace");

// create a new buffer in this workspace and attach to it
workspace.createBuffer("/my/file.txt");
BufferController buffer = workspace.attachToBuffer("/my/file.txt");

// write `hello!` at the beginning of this buffer
buffer.send(new data.TextChange(
	0, 0, "hello!",
	java.util.OptionalLong.empty() // optional, used for error detection
));

// wait for cursor movements
while (true) {
	data.Cursor event = workspace.getCursor().recv();
	System.out.printf("user %s moved on buffer %s\n", event.user, event.buffer);
}
import codemp

# connect first, api.code.mp is managed by hexed.technology
config = codemp.get_default_config()
config.username = "mail@example.net"
config.password = "dont-use-this-password"
client = codemp.connect(config).wait()

# create and join a workspace
client.create_workspace("some-workspace").wait()
workspace = client.join_workspace("some-workspace").wait()

# create a new buffer in this workspace and attach to it
workspace.create("/my/file.txt").wait()
buffer = workspace.attach("/my/file.txt").wait()

# write `hello!` at the beginning of this buffer
buffer.send(
	0, 0, "hello!"
).wait()

# wait for cursor movements
while true:
	event = workspace.cursor().recv().wait()
	print(f"user {event.user} moved on buffer {event.buffer}")
CODEMP = require(codemp)

-- connect first, api.code.mp is managed by hexed.technology
local client = CODEMP.connect({
	username = "mail@example.net", password = "dont-use-this-password"
}):await()

-- create and join a workspace
client:create_workspace("my-workspace"):await()
local workspace = client:join_workspace("my-workspace"):await()

-- create a new buffer in this workspace and attach to it
workspace:create_buffer("/my/file.txt"):await()
local buffer = workspace:attach_buffer("/my/file.txt"):await()

-- write `hello!` at the beginning of this buffer
buffer:send({
	start = 0, finish = 0, 
	content = "hello!"
}):await()

-- wait for cursor movements
while true do
	local event = workspace.cursor:recv():await()
	print("user " .. event.user .. " moved on buffer " .. event.buffer)
end