V0 (#1)

* init physics

* mod mujoco

* init struct Physics

* init environment

* init environment::Composer

* TODO: action <-> control / 'agent' idea implecitly included in `Environment`

* init design.md

* I'll have dinner

* core interfaces

* struct Environment

* todo: actuator

* init Acturators

* refactor

* refactor

* to examples

* remove target git

* start impl Task

* init_episode

* velocity?

* TODOs

* elbow, shoulder

* 2025-07-03 18:06+9:00

* make `should_finish_episode` and `get_reward` to also use `onservation`

* todo: impl wrapper {Data, Model} to provide properly typed way to access physics information

* 2025-07-08 01:28+9:00

* model

* TODO: Physics layer <- `buffer_slices!`

* Physics/user-touchable-buffers

* TODO: acrobot

* TODO: should_finish)episode

* 2025-07-11 05:44+9:00

* bin/qtable.rs

* `LD_LIBRARY_PATH="$MUJOCO_HOME/lib" cargo run --bin train`

* 2025-07-11 11:25+9:00

* git ignore logs

* fix should_finish_episode

* `WARNING: Nan, Inf or huge value in Q{VEL, ACC, POS} at DOF 0`

* where's 'Nan, Inf or huge value'???

* update reward and timestep

* debug_{qpos, qvel}()

* 2025-07-12 08:11+9:00

* 2025-07-12 10:01+9:00

* 2025-07-12 10:04+9:00

* simulate worked

* good camera 0

* 2025-07-12 11:21+9:00

* 2025-07-16 23:03+9:00

* update reward function

* rename `{balance => task}: &AcrobotBalanceTask` arg of `get_reward`

* update rustfmt.toml

* update reward function

* update init_episode and digitzed_state

* try improving train.rs experiment

* origanize train log output

* more improve train log

* fix typo

* use emojis

* train: not warm up if it's restored

* refactor around trained agent

* move current example to personal area

* update following rusty_mujoco

* update following rusty_mujoco

* fix around unused import

* update following rusty_mujoco

* update following rusty_mujoco & update README

* update Cargo.toml

Author: kanarus

.github/workflows/AutoApprove.yml

@@ -0,0 +1,23 @@
+# will be removed when this project has more than one maintainers
+
+name: AutoApprove
+
+on:
+  pull_request:
+    types: [opened, reopened, synchronize, ready_for_review]
+
+jobs:
+  approve:
+    if: |
+      github.event.pull_request.user.login == 'kanarus' &&
+      !github.event.pull_request.draft
+    runs-on: ubuntu-latest
+    permissions:
+      pull-requests: write
+    steps:
+      - uses: actions/checkout@v4
+      - name: approve
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          gh pr review ${{ github.event.number }} --approve

.github/workflows/CI.yml

@@ -6,7 +6,7 @@ on:
     branches: [main, v*]
 
 jobs:
-  CI:
+  build:
     runs-on: ubuntu-latest
 
     strategy:
@@ -16,6 +16,18 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
-      - run: rustup update && rustup default ${{ matrix.toolchain }}
-
-      - run: cargo test
+      - run: |
+          rustup update
+          rustup default ${{ matrix.toolchain }}
+          rustup component add rustfmt  ### required for rusty_mujoco to build ###
+ 
+      - name: install mujoco and set MUJOCO_DIR
+        run: |
+          mkdir -p $HOME/.mujoco
+          cd $HOME/.mujoco
+          wget https://github.com/google-deepmind/mujoco/releases/download/3.3.2/mujoco-3.3.2-linux-x86_64.tar.gz
+          tar -xzf mujoco-3.3.2-linux-x86_64.tar.gz
+          echo "MUJOCO_DIR=$HOME/.mujoco/mujoco-3.3.2" >> $GITHUB_ENV
+          echo "LD_LIBRARY_PATH=$HOME/.mujoco/mujoco-3.3.2/lib:$LD_LIBRARY_PATH" >> $GITHUB_ENV
+          
+      - run: cargo build

.gitignore

@@ -1,2 +1,2 @@
-/target
-Cargo.lock
+**/target
+**/Cargo.lock

Cargo.toml

@@ -8,9 +8,9 @@ homepage      = "https://crates.io/crates/oxide_control"
 repository    = "https://github.com/rust-control/oxide_control"
 readme        = "README.md"
 license       = "MIT"
-description   = ""
+description   = "Rust software stack for physics-based simulation and Reinforcement Learning environments, using MuJoCo"
 keywords      = ["mujoco", "rl", "ml", "physics", "robotics"]
 categories    = ["science::robotics", "simulation"]
 
 [dependencies]
-rusty_mujoco = { path = "../rusty_mujoco" }
+rusty_mujoco = "0.1.0"

README.md

@@ -0,0 +1,13 @@
+<div align="center">
+    <h1><code>oxide_control</code>: The <a href="https://github.com/google-deepmind/dm_control"><code>dm_control</code></a> layer for Rust</h1>
+</div>
+
+`oxide_control` is a Rust software stack for
+physics-based simulation and Reinforcement Learning environments, using MuJoCo.
+
+This is built up on [rusty_mujoco](https://github.com/rust-control/rusty_mujoco) binding,
+and provides a high-level interface similar to [dm_control](https://github.com/google-deepmind/dm_control) in Python.
+
+## Features
+
+

rustfmt.toml

@@ -0,0 +1 @@
+max_width = 160

src/error.rs

@@ -0,0 +1,82 @@
+use rusty_mujoco::{obj, ObjectId};
+
+pub enum Error {
+    Mujoco(::rusty_mujoco::MjError),
+    Mjs(String),
+    NameNotFound(&'static str),
+    PhysicsDiverged,
+    JointTypeNotMatch {
+        expected: ::rusty_mujoco::bindgen::mjtJoint,
+        found: ::rusty_mujoco::bindgen::mjtJoint,
+    },
+    ActuatorStateless(ObjectId<obj::Actuator>),
+    PluginStateless(ObjectId<obj::Plugin>),
+    BodyNotMocap(ObjectId<obj::Body>),
+}
+
+impl From<::rusty_mujoco::MjError> for Error {
+    fn from(e: ::rusty_mujoco::MjError) -> Self {
+        Error::Mujoco(e)
+    }
+}
+
+impl std::fmt::Debug for Error {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Error::Mujoco(e) => write!(f, "Error::MuJoCo({e:?})"),
+            Error::Mjs(msg) => write!(f, "Error::Mjs({msg})"),
+            Error::NameNotFound(name) => write!(f, "Error::NameNotFound({name})"),
+            Error::PhysicsDiverged => write!(f, "Error::PhysicsDiverged"),
+            Error::JointTypeNotMatch { expected, found } => {
+                write!(f, "Error::JointTypeNotMatch(expected: {expected:?}, found: {found:?})")
+            }
+            Error::ActuatorStateless(actuator_id) => {
+                write!(f, "Error::ActuatorStateless({actuator_id:?})")
+            }
+            Error::PluginStateless(plugin_id) => {
+                write!(f, "Error::PluginStateless({plugin_id:?})")
+            }
+            Error::BodyNotMocap(body_id) => {
+                write!(f, "Error::BodyNotMocap({body_id:?})")
+            }
+        }
+    }
+}
+
+impl std::fmt::Display for Error {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Error::Mujoco(e) => write!(f, "MuJoCo error: {e}"),
+            Error::Mjs(msg) => write!(f, "MuJoCo error: {msg}"),
+            Error::NameNotFound(name) => write!(f, "Given name not found: `{name}`"),
+            Error::PhysicsDiverged => write!(f, "Physics simulation diverged"),
+            Error::JointTypeNotMatch { expected, found } => {
+                write!(f, "Joint type mismatch: expected {expected:?}, found {found:?}")
+            }
+            Error::ActuatorStateless(actuator_id) => {
+                write!(f, "Actuator with ID {actuator_id:?} is stateless unexpectedly")
+            }
+            Error::PluginStateless(plugin_id) => {
+                write!(f, "Plugin with ID {plugin_id:?} is stateless unexpectedly")
+            }
+            Error::BodyNotMocap(body_id) => {
+                write!(f, "Body with ID {body_id:?} is not a mocap body")
+            }
+        }
+    }
+}
+
+impl std::error::Error for Error {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            Error::Mujoco(e) => Some(e),
+            Error::Mjs(_) => None,
+            Error::NameNotFound(_) => None,
+            Error::PhysicsDiverged => None,
+            Error::JointTypeNotMatch { .. } => None,
+            Error::ActuatorStateless(_) => None,
+            Error::PluginStateless(_) => None,
+            Error::BodyNotMocap(_) => None,
+        }
+    }
+}

src/lib.rs

@@ -1,14 +1,88 @@
-pub fn add(left: u64, right: u64) -> u64 {
-    left + right
+pub mod error;
+pub mod physics;
+
+pub use physics::Physics as RawPhysics;
+
+pub trait Physics: std::ops::DerefMut<Target = RawPhysics> {}
+
+pub trait Task {
+    type Physics: Physics;
+    type Observation: Observation<Physics = Self::Physics>;
+    type Action: Action<Physics = Self::Physics>;
+    fn discount(&self) -> f64;
+    fn init_episode(&self, physics: &mut Self::Physics);
+    fn should_finish_episode(&self, observation: &Self::Observation) -> bool;
+    fn get_reward(&self, observation: &Self::Observation, action: &Self::Action) -> f64;
+}
+
+pub trait Observation {
+    type Physics: Physics;
+    fn generate(physics: &Self::Physics) -> Self;
+}
+
+pub trait Action {
+    type Physics: Physics;
+    fn apply(&self, actuators: &mut physics::Actuators<'_>);
+}
+
+pub struct Environment<T: Task> {
+    task: T,
+    physics: T::Physics,
+}
+
+impl<T: Task> Environment<T> {
+    pub fn new(physics: T::Physics, task: T) -> Self {
+        Self { task, physics }
+    }
+
+    pub fn task(&self) -> &T {
+        &self.task
+    }
+
+    pub fn physics(&self) -> &T::Physics {
+        &self.physics
+    }
+    pub fn physics_mut(&mut self) -> &mut T::Physics {
+        &mut self.physics
+    }
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
+pub enum TimeStep<O> {
+    Step {
+        observation: O,
+        reward: f64,
+        discount: f64,
+    },
+    Finish {
+        observation: O,
+        reward: f64,
+    },
+}
+
+impl<T: Task> Environment<T> {
+    pub fn reset(&mut self) -> T::Observation {
+        self.task.init_episode(&mut self.physics);
+        T::Observation::generate(&self.physics)
+    }
+
+    pub fn step(&mut self, action: T::Action) -> TimeStep<T::Observation> {
+        action.apply(&mut self.physics.actuators());
+        self.physics.step();
+
+        let observation = T::Observation::generate(&self.physics);
+        let reward = self.task.get_reward(&observation, &action);
 
-    #[test]
-    fn it_works() {
-        let result = add(2, 2);
-        assert_eq!(result, 4);
+        if self.task.should_finish_episode(&observation) {
+            TimeStep::Finish {
+                observation,
+                reward,
+            }
+        } else {
+            TimeStep::Step {
+                observation,
+                reward,
+                discount: self.task.discount(),
+            }
+        }
     }
 }