imagineering | Copper and Groovy development tools

Rust tooling and editor functions in Copper

Rust work, from edit to review

Copper combines Rust tooling with agent activity and review. Inspect the output before deciding which changes to keep.

Review proposed edits.
Inspect an agent diff and choose which changes to keep.

fn parse_count(input: &str) -> Result<usize, String> {
    let trimmed = input.trim();
    if trimmed.is_empty() {
        return Err("missing count".into());
    }
    let count = trimmed
        .parse::<usize>()
        .map_err(|error| error.to_string())?;
    Ok(count)
}
 
fn main() {
    println!("{:?}", parse_count("42"));
}

fn parse_count(input: &str) -> Result<usize, String> {
    let trimmed = input.trim();
    if trimmed.is_empty() {
        return Err("missing count".into());
    }
    let count = trimmed
        .parse::<usize>()
        .map_err(|error| error.to_string())?;
    if count == 0 {
        return Err("count must be positive".into());
    }
    Ok(count)
}
// Proposed change: reject zero counts.

Review changesDiff

Rust language tools
Navigate symbols and inspect rust-analyzer diagnostics.

fn parse_count(input: &str) -> Result<usize, String> {
    let trimmed = input.trim();
    if trimmed.is_empty() {
        return Err("missing count".into());
    }
    let count = trimmed
        .parse::<usize>()
        .map_err(|error| error.to_string())?;
    Ok(count)
}
 
fn main() {
    println!("{:?}", parse_count("42"));
}

Inspect diagnostics

Tools in one application
Stage Git hunks, use the terminal, and step through Rust.

Configurable agent tools
Connect MCP servers and review tool permissions.

Agent tools · Example

Read files

Review

Search project

Run a command

Review

Review a diff

Tool permissions

Review

Configured MCP tools

Inspect agent activity
Follow tool calls, command output, and proposed edits.

Review parser diff

Example task • Agent • copper/parser...

Inspect test output

Example task • Agent • copper/parser...

Plan a Rust change

Example task • Agent • copper/parser...

Cargo and test tools
Explore Cargo targets, run checks, and select Rust tests.

Illustrative Cargo session
Example project: copper-demo
$ cargo check
    Checking copper-demo
    Finished dev profile
$ cargo test
    Running unit tests
running 3 tests
test parse_valid_input ... ok
test reject_invalid_input ... ok
test keep_error_context ... ok
test result: ok. 3 passed
$ cargo clippy
    Checking copper-demo
    Finished dev profile
Review diagnostics and command output.
This example does not execute commands.

Cargo test example

Follow a Rust change from the editor to Cargo output, a stopped debugger, and the diff you choose to keep.

Copper

Rust development

Tools for the languages you use

Copper focuses on Rust. Groovy is in development for the JVM.
C, C++, C#, Python, and other language tools are planned.

Future tools

PlannedPlanned

tools

Planned tools for more languages.

Roadmap status

Planned language focus:

C

C++

C#

Python

Other languages

Copper

Development

RustRust

product

Rust editing, from build to review.

Copper build guide

Development features:

Rust editing and rust-analyzer

Cargo targets, checks, and Clippy

Selected tests and terminal output

Breakpoints, stepping, and variables

Git staging and hunk review

Native agents, ACP, and MCP

Inspect tool activity and changes

Groovy

PlannedPlanned

product

In development for Java and Kotlin.

Development status

In the development candidate:

Planned JVM development product

Java and Kotlin language tools

Maven and Gradle wrapper Tasks

Selected JUnit and Java debugging

No public installer

Keep the work inspectable

Editing, commands, agent activity, and review in Copper.
Groovy is being developed for Java and Kotlin projects.

Copper combines Rust editing, rust-analyzer, Cargo, tests, terminal, Git, debugging, and agent tools. Inspect command output and proposed changes, then choose which edits to keep.

Copper

Rust development

Select a Cargo target or Rust test, run it, then read its results in the Tests panel and terminal.

Build and test

Cargo and terminal

Inspect Git diffs and stage hunks. Review agent edits with keep/reject controls and checkpoints.

Review changes

Developer decisions

Stop at a Rust breakpoint, step through the code, and inspect variables with a configured debug adapter.

Debug Rust

Breakpoints and stepping

Choose a provider or ACP agent. Authentication, local execution, and tools depend on that integration.

Agent connections

Providers and ACP

Use Rust and rust-analyzer defaults for syntax, symbols, navigation, and diagnostics.

Edit and navigate

Rust language tools

Groovy is in development for Java and Kotlin. Candidate builds have local Maven, Gradle, JUnit, and Java debugging evidence. It remains planned, with no public installer.

Groovy

Planned JVM product

Frequently Asked Questions

Product status, agent configuration, and what is included in Copper.

What can I do with Copper?

Is Groovy available?

Groovy remains planned, with no public installer or enabled release targets. Its Java and Kotlin development candidate has local macOS ARM64 evidence for cached Maven and Gradle builds, selected JUnit tests, and Java main debugging. Dependency inspection has partial provider coverage; test debugging, packaging, and broader platform qualification remain open. The product name does not establish support for the Groovy language, which remains a separate release decision.

Can I choose an agent or model provider?

How are agent changes reviewed?

Which other language tools are planned?

Where can I read the source and build instructions?

Explore Copper for Rust

Build Copper from source and explore its Rust tools. GitHub repository access is required. Groovy and future language products remain planned.

Focused tools for developers

Rust work, from edit to review

Tools for the languages you use

Keep the work inspectable

Frequently Asked Questions

Explore Copper for Rust