diff --git a/tinker_cookbook/recipes/code_rl/README.md b/tinker_cookbook/recipes/code_rl/README.md
new file mode 100644
index 0000000..6925fc4
--- /dev/null
+++ b/tinker_cookbook/recipes/code_rl/README.md
@@ -0,0 +1,45 @@
+# Replicating DeepCoder with Tinker
+
+Competitive programming problems are a common testbed for RL with LLMs. The recent [DeepCoder](https://pretty-radio-b75.notion.site/DeepCoder-A-Fully-Open-Source-14B-Coder-at-O3-mini-Level-1cf81902c14680b3bee5eb349a512a51) blog post introduces a dataset and training pipeline for this purpose. This recipe demonstrates a similar setup using `Qwen3-4B-Instruct-2507`.
+
+## Running This Demo
+
+### Sandboxing
+
+Sandboxing is essential for safely executing generated code during training and evaluation. We use [Sandbox Fusion](https://bytedance.github.io/SandboxFusion/) to sandbox code execution. You can start a local sandbox in Docker with:
+
+```bash
+docker run -it -p 8080:8080 \
+    -v ${TINKER_COOKBOOK_ROOT}/tinker_cookbook/recipes/code_rl/sandbox_config/local.yaml:/root/sandbox/sandbox/configs/local.yaml \
+    volcengine/sandbox-fusion:server-20250609
+```
+
+Here, `${TINKER_COOKBOOK_ROOT}` is the absolute path to your local `tinker-cookbook` repository. The training script reads the sandbox endpoint from the `SANDBOX_URL` environment variable. By default it uses `http://localhost:8080/run_code`. Example:
+
+```bash
+export SANDBOX_URL=http://localhost:8080/run_code
+```
+
+If you prefer not to use Docker, you can set up the sandbox manually by following the instructions in the [Sandbox Fusion repository](https://github.com/bytedance/SandboxFusion?tab=readme-ov-file#installation).
+
+### Example command
+
+Train a `Qwen3-4B-Instruct-2507` model with:
+
+```bash
+python -m tinker_cookbook.recipes.code_rl.train \
+    model_name="Qwen/Qwen3-4B-Instruct-2507" \
+    group_size=8 groups_per_batch=128 \
+    learning_rate=4e-5 \
+    lora_rank=32 \
+    max_tokens=24576
+```
+
+After 100 steps of training, you can expect the following performance on **LiveCodeBench v6 (2025.02–2025.05)**:
+
+| Model | Pass@1 | Pass@8 |
+|-------|--------|--------|
+| Qwen3-4B-Instruct-2507 (before training) | 33.8% | 44.3% |
+| Qwen3-4B-Instruct-2507 (after 100 steps) | 42.7% | 55.0% |
+
+[1] Luo, M., Tan, S., Huang, R., Patel, A., Ariyak, A., Wu, Q., Shi, X., Xin, R., Cai, C., Weber, M., Zhang, C., Li, L. E., Popa, R. A., & Stoica, I. (2025). DeepCoder: A fully open-source 14B coder at O3-mini level.
diff --git a/tinker_cookbook/recipes/code_rl/code_env.py b/tinker_cookbook/recipes/code_rl/code_env.py
new file mode 100644
index 0000000..5f88923
--- /dev/null
+++ b/tinker_cookbook/recipes/code_rl/code_env.py
@@ -0,0 +1,283 @@
+import json
+from functools import partial
+from typing import Any, Literal, Sequence, cast
+
+import chz
+from datasets import Dataset, concatenate_datasets, load_dataset
+
+import tinker
+from tinker_cookbook.recipes.code_rl.code_grading import (
+    extract_code_from_model,
+    sandbox_check_correctness,
+    taco_to_lcb_format,
+)
+from tinker_cookbook.recipes.code_rl.lcb_utils import fetch_live_code_bench_system_prompt
+from tinker_cookbook import renderers
+from tinker_cookbook.rl.problem_env import ProblemEnv, ProblemGroupBuilder, logger
+from tinker_cookbook.rl.types import (
+    Action,
+    EnvGroupBuilder,
+    RLDataset,
+    RLDatasetBuilder,
+    StepResult,
+)
+from tinker_cookbook.tokenizer_utils import get_tokenizer
+from tinker_cookbook.utils import logtree
+
+
+def _load_deepcoder_split(split: Literal["train", "test"]) -> Dataset:
+    if split == "train":
+        datasets = [
+            cast(
+                Dataset,
+                load_dataset("agentica-org/DeepCoder-Preview-Dataset", name=name, split="train"),
+            )
+            for name in ("primeintellect", "taco", "lcbv5")
+        ]
+    elif split == "test":
+        datasets = [
+            cast(
+                Dataset,
+                load_dataset("agentica-org/DeepCoder-Preview-Dataset", name=name, split="test"),
+            )
+            for name in ("codeforces", "lcbv5")
+        ]
+    return cast(Dataset, concatenate_datasets(datasets))
+
+
+def _ensure_dict(metadata: Any) -> dict[str, Any]:
+    if isinstance(metadata, str):
+        try:
+            metadata = json.loads(metadata)
+        except json.JSONDecodeError:
+            logger.warning("Failed to deserialize metadata: %s", metadata)
+            return {}
+    if isinstance(metadata, dict):
+        return metadata
+    return {}
+
+
+def _normalize_tests(raw_tests: Any, metadata: dict[str, Any]) -> list[dict[str, Any]]:
+    tests = raw_tests
+    if isinstance(tests, str):
+        try:
+            tests = json.loads(tests)
+        except json.JSONDecodeError:
+            logger.warning("Failed to deserialize tests. Dropping sample.")
+            return []
+    if isinstance(tests, dict) and "inputs" in tests and "outputs" in tests:
+        tests = taco_to_lcb_format(tests)
+    if isinstance(tests, dict):
+        tests = [tests]
+
+    normalized: list[dict[str, Any]] = []
+    for test in tests or []:
+        if not isinstance(test, dict):
+            continue
+        testtype = test.get("testtype") or "stdin_stdout"
+        test_metadata = _ensure_dict(test.get("metadata", {}))
+        if testtype == "functional":
+            func_name = test_metadata.get("func_name") or metadata.get("func_name")
+            if func_name is not None:
+                test_metadata["func_name"] = str(func_name)
+        normalized.append(
+            {
+                "input": str(test.get("input", "")),
+                "output": str(test.get("output", "")),
+                "testtype": testtype,
+                "metadata": test_metadata or {"func_name": None},
+            }
+        )
+    return normalized
+
+
+def _build_question(example: dict[str, Any]) -> str | None:
+    # Prefer preprocessed question if available.
+    question = example.get("question") or example.get("prompt") or example.get("problem")
+    if not isinstance(question, str) or not question.strip():
+        return None
+    starter_code = example.get("starter_code")
+    if isinstance(starter_code, str) and starter_code.strip():
+        return fetch_live_code_bench_system_prompt(question, starter_code)
+    return fetch_live_code_bench_system_prompt(question)
+
+
+class CodeEnv(ProblemEnv):
+    def __init__(
+        self,
+        problem: str,
+        tests: list[dict[str, Any]],
+        renderer: renderers.Renderer,
+        convo_prefix: list[renderers.Message] | None = None,
+        format_coef: float = 0.1,
+        reward_timeout: int = 6,
+    ):
+        super().__init__(renderer, convo_prefix, format_coef=format_coef)
+        self.problem = problem
+        self.tests = tests
+        self.reward_timeout = reward_timeout
+
+    def get_question(self) -> str:
+        return self.problem
+
+    def check_format(self, sample_str: str) -> bool:
+        return extract_code_from_model(sample_str) is not None
+
+    def check_answer(self, sample_str: str) -> bool:
+        """Not used - CodeEnv uses async check_sandbox_correctness instead."""
+        return False
+
+    async def check_sandbox_correctness(self, sample_str: str) -> bool:
+        """Check if the code passes all test cases using sandbox execution."""
+        code = extract_code_from_model(sample_str)
+        if code is None:
+            logtree.log_text("No code block detected in response.")
+            return False
+
+        try:
+            success, details = await sandbox_check_correctness(
+                self.tests, code, timeout=self.reward_timeout
+            )
+            status = "✓" if success else "✗"
+            logtree.log_text(
+                f"Sandbox result {status}: {'All tests passed' if success else 'Failed'}"
+            )
+            return success
+        except Exception as exc:
+            logger.warning("Sandbox check failed: %s", exc, exc_info=True)
+            logtree.log_text(f"Sandbox check failed: {exc}")
+            return False
+
+    def get_reference_answer(self) -> str:
+        return ""
+
+    async def step(self, action: Action) -> StepResult:
+        message, parse_success = self.renderer.parse_response(action)
+        content = message["content"]
+        format_ok_bool = bool(parse_success) and self.check_format(content)
+        correct_answer_bool = await self.check_sandbox_correctness(content)
+        format_score = float(format_ok_bool)
+        correct_score = float(correct_answer_bool)
+        total_reward = self.format_coef * (format_score - 1.0) + correct_score
+
+        logtree.log_text(f"Problem: {self.get_question()}")
+        logtree.log_text(f"Response: {content}")
+        if reference := self.get_reference_answer():
+            logtree.log_text(f"Reference Answer: {reference}")
+        logtree.log_text(
+            f"Format Valid: {'✓' if format_ok_bool else '✗'}, "
+            f"Correct: {'✓' if correct_answer_bool else '✗'}, "
+            f"Reward: {total_reward:.2f}"
+        )
+
+        return StepResult(
+            reward=total_reward,
+            episode_done=True,
+            next_observation=tinker.ModelInput.empty(),
+            next_stop_condition=self.stop_condition,
+            metrics={
+                "format": format_score,
+                "correct": correct_score,
+            },
+        )
+
+
+class DeepcoderDataset(RLDataset):
+    def __init__(
+        self,
+        batch_size: int,
+        group_size: int,
+        renderer: renderers.Renderer,
+        convo_prefix: list[renderers.Message] | None = None,
+        split: Literal["train", "test"] = "train",
+        seed: int = 0,
+        format_coef: float = 0.1,
+        reward_timeout: int = 6,
+    ):
+        self.ds = _load_deepcoder_split(split)
+        if split == "train":
+            self.ds = self.ds.shuffle(seed=seed)
+        self.batch_size = batch_size
+        self.group_size = group_size if split == "train" else 1
+        self.renderer = renderer
+        self.convo_prefix = convo_prefix
+        self.format_coef = format_coef
+        self.reward_timeout = reward_timeout
+
+    def __len__(self) -> int:
+        return (len(self.ds) + self.batch_size - 1) // self.batch_size
+
+    def get_batch(self, index: int) -> Sequence[EnvGroupBuilder]:
+        start = index * self.batch_size
+        end = min((index + 1) * self.batch_size, len(self.ds))
+        if start >= end:
+            raise IndexError("Incorrect batch index for DeepcoderDataset")
+        builders: list[EnvGroupBuilder] = []
+        for row in self.ds.select(range(start, end)):
+            builder = self._make_env_group_builder(cast(dict[str, Any], row), self.group_size)
+            if builder is not None:
+                builders.append(builder)
+        return builders
+
+    def _make_env_group_builder(
+        self, example: dict[str, Any], group_size: int
+    ) -> ProblemGroupBuilder | None:
+        metadata = _ensure_dict(example.get("metadata", {}))
+        tests = _normalize_tests(example.get("tests") or example.get("ground_truth"), metadata)
+        if not tests:
+            logger.warning("Skipping sample without valid tests.")
+            return None
+        question = _build_question(example)
+        if question is None:
+            logger.warning("Skipping sample without question text.")
+            return None
+        return ProblemGroupBuilder(
+            env_thunk=partial(
+                CodeEnv,
+                question,
+                tests,
+                self.renderer,
+                convo_prefix=self.convo_prefix,
+                format_coef=self.format_coef,
+                reward_timeout=self.reward_timeout,
+            ),
+            num_envs=group_size,
+            dataset_name="deepcoder",
+        )
+
+
+@chz.chz
+class DeepcoderDatasetBuilder(RLDatasetBuilder):
+    batch_size: int
+    model_name_for_tokenizer: str
+    renderer_name: str
+    group_size: int
+    convo_prefix: list[renderers.Message] | None = None
+    seed: int = 0
+    format_coef: float = 0.1
+    reward_timeout: int = 6
+
+    async def __call__(self) -> tuple[DeepcoderDataset, DeepcoderDataset]:
+        tokenizer = get_tokenizer(self.model_name_for_tokenizer)
+        renderer = renderers.get_renderer(self.renderer_name, tokenizer=tokenizer)
+        train_ds = DeepcoderDataset(
+            batch_size=self.batch_size,
+            group_size=self.group_size,
+            renderer=renderer,
+            convo_prefix=self.convo_prefix,
+            split="train",
+            seed=self.seed,
+            format_coef=self.format_coef,
+            reward_timeout=self.reward_timeout,
+        )
+        test_ds = DeepcoderDataset(
+            batch_size=self.batch_size,
+            group_size=1,
+            renderer=renderer,
+            convo_prefix=self.convo_prefix,
+            split="test",
+            seed=self.seed,
+            format_coef=self.format_coef,
+            reward_timeout=self.reward_timeout,
+        )
+        return train_ds, test_ds
diff --git a/tinker_cookbook/recipes/code_rl/code_grading.py b/tinker_cookbook/recipes/code_rl/code_grading.py
new file mode 100644
index 0000000..a6c291d
--- /dev/null
+++ b/tinker_cookbook/recipes/code_rl/code_grading.py
@@ -0,0 +1,159 @@
+"""
+Code grading utilities for RL training.
+
+Uses Sandbox Fusion for safe code execution.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import base64
+import json
+import os
+import re
+from typing import Any
+
+import aiohttp
+
+from tinker_cookbook.recipes.code_rl.lcb_utils import TEST_UTIL, TEST_CODE
+
+# Sandbox configuration
+SANDBOX_URL = os.getenv("SANDBOX_URL", "http://localhost:8080/run_code")
+SANDBOX_MAX_CONCURRENCY = int(os.getenv("SANDBOX_MAX_CONCURRENCY", "4"))
+
+# Sandbox session management
+_SANDBOX_SESSION: aiohttp.ClientSession | None = None
+_SANDBOX_SESSION_LOCK = asyncio.Lock()
+
+
+async def _get_sandbox_session() -> aiohttp.ClientSession:
+    """
+    Get or create a shared aiohttp session with connection limits.
+
+    The TCPConnector limits concurrent connections to SANDBOX_MAX_CONCURRENCY.
+    When all connections are busy, additional requests automatically wait in a queue
+    until a connection becomes available.
+    """
+    global _SANDBOX_SESSION
+
+    async with _SANDBOX_SESSION_LOCK:
+        if _SANDBOX_SESSION is None or _SANDBOX_SESSION.closed:
+            connector = aiohttp.TCPConnector(
+                limit=SANDBOX_MAX_CONCURRENCY,
+                limit_per_host=SANDBOX_MAX_CONCURRENCY,
+            )
+            timeout = aiohttp.ClientTimeout(total=6000)
+            _SANDBOX_SESSION = aiohttp.ClientSession(
+                connector=connector,
+                timeout=timeout,
+            )
+        return _SANDBOX_SESSION
+
+
+def _b64encode(content: str) -> str:
+    return base64.b64encode(content.encode("utf-8")).decode("utf-8")
+
+
+def extract_code_from_model(model_response: str) -> str | None:
+    """
+    Extract the last fenced code block from a model response.
+    """
+    code_blocks = re.findall(r"```(?:\w+)?\n(.*?)```", model_response, re.DOTALL)
+    if not code_blocks:
+        return None
+    return code_blocks[-1].strip()
+
+
+def postprocess_lcb_sample(sample: list[dict[str, Any]]) -> dict[str, str]:
+    sample_inputs = [item["input"] for item in sample]
+    sample_outputs = [item["output"] for item in sample]
+
+    sample_dict: dict[str, Any] = {
+        "inputs": sample_inputs,
+        "outputs": sample_outputs,
+    }
+
+    if sample[0].get("testtype") == "functional":
+        metadata = sample[0].get("metadata", {})
+        fn_name = metadata.get("func_name")
+        if fn_name is None:
+            raise AssertionError(f"Function name missing in metadata: {metadata}. Sample: {sample}")
+        sample_dict["fn_name"] = fn_name
+
+    return {
+        "input_output": json.dumps(sample_dict),
+    }
+
+
+async def sandbox_check_correctness(
+    sample: list[dict[str, Any]], generation: str, timeout: int = 6
+) -> tuple[bool, dict[str, Any]]:
+    """Check correctness of generated code using sandbox execution."""
+    assert len(sample) >= 1, "Sample must contain at least one test case"
+
+    # Process test cases
+    test_cases = postprocess_lcb_sample(sample)
+
+    try:
+        test_cnt = len(json.loads(test_cases["input_output"])["inputs"])
+        total_timeout = (timeout + 1) * test_cnt + 5
+
+        test_code = TEST_CODE % {"timeout": timeout}
+        asset = {
+            "test_cases.txt": _b64encode(json.dumps(test_cases)),
+            "code.py": _b64encode(generation),
+            "testing_util.py": _b64encode(TEST_UTIL),
+        }
+
+        payload = {
+            "code": test_code,
+            "language": "python",
+            "run_timeout": total_timeout,
+            "files": asset,
+        }
+
+        session = await _get_sandbox_session()
+        async with session.post(SANDBOX_URL, json=payload) as result:
+            if result.status != 200:
+                raise Exception(
+                    f"Sandbox API responded with code {result.status}: {await result.text()}"
+                )
+            resp = await result.json()
+            if resp.get("status") == "SandboxError":
+                raise Exception(f"Sandbox responded with error: {resp.get('message')}")
+
+            # Check if all tests passed
+            all_passed = resp.get("status") == "Success"
+            return all_passed, resp
+    except Exception as e:
+        return False, {"error": str(e)}
+
+
+def taco_to_lcb_format(tests: dict[str, Any]) -> list[dict[str, Any]]:
+    """
+    Convert TACO-style tests to LiveCodeBench format.
+    """
+    inputs = tests.get("inputs", [])
+    outputs = tests.get("outputs", [])
+
+    n = max(len(inputs), len(outputs))
+
+    test_cases: list[dict[str, Any]] = []
+    for i in range(n):
+        inp = inputs[i] if i < len(inputs) else (inputs[0] if inputs else "")
+        out = outputs[i] if i < len(outputs) else (outputs[0] if outputs else "")
+        if isinstance(out, list):
+            out = out[0]
+        case: dict[str, Any] = {
+            "input": inp,
+            "output": out,
+            "metadata": {},
+        }
+        if "fn_name" in tests:
+            case["testtype"] = "functional"
+            case["metadata"]["func_name"] = tests["fn_name"]
+        else:
+            case["testtype"] = "stdin_stdout"
+        test_cases.append(case)
+
+    return test_cases
diff --git a/tinker_cookbook/recipes/code_rl/lcb_utils.py b/tinker_cookbook/recipes/code_rl/lcb_utils.py
new file mode 100644
index 0000000..c72dafc
--- /dev/null
+++ b/tinker_cookbook/recipes/code_rl/lcb_utils.py
@@ -0,0 +1,821 @@
+"""
+LiveCodeBench testing utilities for sandbox execution.
+
+Adapted from https://github.com/LiveCodeBench/LiveCodeBench
+
+This module provides TEST_UTIL and TEST_CODE strings that are used to execute
+and validate code submissions in a sandboxed environment. These utilities handle
+both call-based and standard input/output test cases.
+"""
+
+TEST_UTIL = r'''
+import ast
+import json
+import sys
+import faulthandler
+import platform
+
+# used for debugging to time steps
+from datetime import datetime
+
+# to run the solution files we're using a timing based approach
+import signal
+
+import numpy as np
+
+# for capturing the stdout
+from io import StringIO
+
+# used for testing the code that reads from input
+from unittest.mock import patch, mock_open
+
+#from pyext import RuntimeModule
+
+from enum import Enum
+
+import types
+
+
+class RuntimeModule:
+    @staticmethod
+    def from_string(name, _, code):
+        module = types.ModuleType(name)
+        exec(code, module.__dict__)
+        return module
+
+
+def truncatefn(s, length=300):
+    assert isinstance(s, str)
+    if len(s) <= length:
+        return s
+
+    return s[: length // 2] + "...(truncated) ..." + s[-length // 2 :]
+
+
+class CODE_TYPE(Enum):
+    call_based = 0
+    standard_input = 1
+
+
+# stuff for setting up signal timer
+class TimeoutException(Exception):
+    pass
+
+
+def timeout_handler(signum, frame):
+    print("alarm went off")
+    # return
+    raise TimeoutException
+
+
+signal.signal(signal.SIGALRM, timeout_handler)
+# timeout = 6  # seconds
+
+
+# used to capture stdout as a list
+# from https://stackoverflow.com/a/16571630/6416660
+# alternative use redirect_stdout() from contextlib
+class Capturing(list):
+    def __enter__(self):
+        self._stdout = sys.stdout
+        sys.stdout = self._stringio = StringIO()
+        # Make closing the StringIO a no-op
+        self._stringio.close = lambda x: 1
+        return self
+
+    def __exit__(self, *args):
+        self.append(self._stringio.getvalue())
+        del self._stringio  # free up some memory
+        sys.stdout = self._stdout
+
+
+def only_int_check(val):
+    return isinstance(val, int)
+
+
+def string_int_check(val):
+    return isinstance(val, str) and val.isdigit()
+
+
+def combined_int_check(val):
+    return only_int_check(val) or string_int_check(val)
+
+
+def run_test(sample, test=None, debug=False, timeout=6):
+    """
+    if test(generated_code) is not None it'll try to run the code.
+    otherwise it'll just return an input and output pair.
+    """
+    # Disable functionalities that can make destructive changes to the test.
+    reliability_guard()
+
+    if debug:
+        print(f"start = {datetime.now().time()}")
+
+    try:
+        in_outs = json.loads(sample["input_output"])
+    except ValueError:
+        in_outs = None
+    if in_outs:
+        if in_outs.get("fn_name") is None:
+            which_type = CODE_TYPE.standard_input  # Standard input
+            method_name = None
+        else:
+            which_type = CODE_TYPE.call_based  # Call-based
+            method_name = in_outs["fn_name"]
+
+    if debug:
+        print(f"loaded input_output = {datetime.now().time()}")
+
+    if test is None:
+        assert False, "should not happen: test code is none"
+        return in_outs, {"error": "no test code provided"}
+    elif test is not None:
+        results = []
+        sol = "from string import *\nfrom re import *\nfrom datetime import *\nfrom collections import *\nfrom heapq import *\nfrom bisect import *\nfrom copy import *\nfrom math import *\nfrom random import *\nfrom statistics import *\nfrom itertools import *\nfrom functools import *\nfrom operator import *\nfrom io import *\nfrom sys import *\nfrom json import *\nfrom builtins import *\nfrom typing import *\nimport string\nimport re\nimport datetime\nimport collections\nimport heapq\nimport bisect\nimport copy\nimport math\nimport random\nimport statistics\nimport itertools\nimport functools\nimport operator\nimport io\nimport sys\nimport json\nsys.setrecursionlimit(6*10**5)\n"
+        if debug:
+            print(f"loading test code = {datetime.now().time()}")
+
+        if which_type == CODE_TYPE.call_based:
+
+            sol += test
+            if debug:
+                print(f"sol = {sol}")
+            signal.alarm(timeout)
+            try:
+                tmp_sol = RuntimeModule.from_string("tmp_sol", "", sol)
+                if "class Solution" not in test:
+                    tmp = tmp_sol
+                else:
+                    tmp = tmp_sol.Solution()
+                signal.alarm(0)
+            except Exception as e:
+                signal.alarm(0)
+                if debug:
+                    print(f"type 0 compilation error = {e}")
+                results.append(-2)
+                return results, {
+                    "error": repr(e),
+                    "error_code": -1,
+                    "error_message": "Compilation Error",
+                }
+            signal.alarm(0)
+
+        elif which_type == CODE_TYPE.standard_input:
+            # sol
+            # if code has if __name__ == "__main__": then remove it
+            try:
+                astree = ast.parse(test)
+                last_block = astree.body[-1]
+                if isinstance(last_block, ast.If):
+                    condition = last_block.test
+                    if ast.unparse(condition).strip() == "__name__ == '__main__'":
+                        test = (
+                            ast.unparse(astree.body[:-1])
+                            + "\n"
+                            + ast.unparse(last_block.body)
+                        )
+            except:
+                pass
+
+            tmp_test = test.split("\n")
+
+            new_test = []
+            for x in tmp_test:
+                if (not x.startswith("from ")) and (not x.startswith("import ")):
+                    new_test.append("\t" + x + "\n")
+                else:
+                    new_test.append(x + "\n")
+            tmp_test = new_test
+
+            new_test = ""
+            started = False
+            for i in tmp_test:
+                if i.startswith("\t") and not started:
+                    new_test += "stdin = sys.stdin\nstdout = sys.stdout\n"
+                    new_test += "def code():\n"
+                    new_test += i
+                    started = True
+                elif started and ((i.startswith("from ")) or (i.startswith("import "))):
+                    new_test += "\t" + i
+                else:
+                    new_test += i
+            tmp_test = new_test
+
+            sol += tmp_test
+            if debug:
+                print(f"sol = {sol}")
+            method_name = "code"
+            signal.alarm(timeout)
+            try:
+                tmp_sol = RuntimeModule.from_string("tmp_sol", "", sol)
+                tmp = tmp_sol
+                signal.alarm(0)
+            except Exception as e:
+                signal.alarm(0)
+                if debug:
+                    print(f"type 1 compilation error = {e}")
+                results.append(-2)
+                return results, {
+                    "error": repr(e),
+                    "error_code": -1,
+                    "error_message": "Compilation Error",
+                }
+            signal.alarm(0)
+        if debug:
+            print(f"get method = {datetime.now().time()}")
+
+        try:
+            method = getattr(tmp, method_name)  # get_attr second arg must be str
+        except:
+            signal.alarm(0)
+            e = sys.exc_info()
+            print(f"unable to get function error = {e}")
+            results.append(-2)
+            return results, {
+                "error": repr(e),
+                "error_code": -1,
+                "error_message": "Unable to extract code",
+            }
+
+        for index, inputs in enumerate(in_outs["inputs"]):
+            raw_inputs = inputs
+            raw_outputs = in_outs["outputs"][index]
+            if which_type == CODE_TYPE.call_based:
+                inputs = [json.loads(line) for line in inputs.split("\n")]
+                in_outs["outputs"][index] = json.loads(in_outs["outputs"][index])
+
+                truncate_line_size = 300 // (raw_inputs.count("\n") + 1)
+                raw_inputs = "\n".join(
+                    [
+                        truncatefn(line, truncate_line_size)
+                        for line in raw_inputs.strip().split("\n")
+                    ]
+                )
+                raw_outputs = truncatefn(raw_outputs, 200)
+            else:
+                raw_inputs = truncatefn(raw_inputs)
+                raw_outputs = truncatefn(raw_outputs, 200)
+            # JSON forces dictionaries to have string keys; this undoes this (assuming a singleton list)
+            try:
+                if isinstance(inputs[0], dict):
+                    inputs = [{int(k): v for k, v in inputs[0].items()}]
+            except:
+                True
+            try:
+                if isinstance(in_outs["outputs"][index], dict):
+                    in_outs["outputs"][index] = [
+                        {int(k): v for k, v in in_outs["outputs"][index].items()}
+                    ]
+            except:
+                True
+            try:
+                if isinstance(in_outs["outputs"][index][0], dict):
+                    in_outs["outputs"][index] = [
+                        {int(k): v for k, v in in_outs["outputs"][index][0].items()}
+                    ]
+            except:
+                True
+
+            if debug:
+                print(
+                    f"time: {datetime.now().time()} testing index = {index}  inputs = {inputs}, {type(inputs)}. type = {which_type}"
+                )
+            if which_type == CODE_TYPE.call_based:  # Call-based
+                signal.alarm(timeout)
+                faulthandler.enable()
+                try:
+                    output = method(*inputs)
+                    raw_true_output = output
+
+                    raw_true_output_copy = json.dumps(output)
+                    raw_true_output_copy = truncatefn(raw_true_output_copy, 200)
+
+                    # ground truth sequences are not tuples
+                    if isinstance(output, tuple):
+                        output = list(output)
+
+                    tmp_result = output == in_outs["outputs"][index]
+                    if (
+                        isinstance(in_outs["outputs"][index], list)
+                        and in_outs["outputs"][index]
+                    ):
+                        tmp_result = tmp_result or (
+                            output == in_outs["outputs"][index][0]
+                        )
+
+                    # ground truth sequences are not tuples
+                    try:
+                        if isinstance(output[0], tuple):
+                            tmp_result = tmp_result or (
+                                [list(x) for x in output]
+                                == in_outs["outputs"][index][0]
+                            )
+                    except:
+                        True
+                    results.append(tmp_result)
+                    if tmp_result != True:
+                        return results, {
+                            "output": raw_true_output_copy,
+                            "expected": raw_outputs,
+                            "inputs": raw_inputs,
+                            "error_code": -2,
+                            "error_message": "Wrong Answer",
+                        }
+                    # reset the alarm
+                    signal.alarm(0)
+                except Exception as e:
+                    signal.alarm(0)
+                    faulthandler.disable()
+                    if debug:
+                        print(
+                            f"Standard input runtime error or time limit exceeded error = {e}"
+                        )
+                    results.append(-1)
+                    if "timeoutexception" in repr(e).lower():
+                        return results, {
+                            "error": repr(e),
+                            "error_code": -3,
+                            "error_message": "Time Limit Exceeded",
+                            "inputs": raw_inputs,
+                            "expected": raw_outputs,
+                        }
+                    else:
+                        return results, {
+                            "error": repr(e),
+                            "error_code": -4,
+                            "error_message": "Runtime Error",
+                            "inputs": raw_inputs,
+                            "expected": raw_outputs,
+                        }
+                faulthandler.disable()
+                signal.alarm(0)
+                if debug:
+                    print(
+                        f"outputs = {output}, test outputs = {in_outs['outputs'][index]}, inputs = {inputs}, {type(inputs)}, {output == [in_outs['outputs'][index]]}"
+                    )
+            elif which_type == CODE_TYPE.standard_input:  # Standard input
+                faulthandler.enable()
+                passed = False
+
+                if isinstance(inputs, list):
+                    inputs = "\n".join(inputs)
+                if isinstance(in_outs["outputs"][index], list):
+                    in_outs["outputs"][index] = "\n".join(in_outs["outputs"][index])
+
+                signal.alarm(timeout)
+                with Capturing() as output:
+                    try:
+                        call_method(method, inputs)
+                        # reset the alarm
+                        signal.alarm(0)
+                        passed = True
+                    except Exception as e:
+                        # runtime error or took too long
+                        signal.alarm(0)
+                        print(
+                            f"Call-based runtime error or time limit exceeded error = {repr(e)}{e}"
+                        )
+                        results.append(-1)
+                        if "timeoutexception" in repr(e).lower():
+                            return results, {
+                                "error": repr(e),
+                                "error_code": -3,
+                                "error_message": "Time Limit Exceeded",
+                                "inputs": raw_inputs,
+                                "expected": raw_outputs,
+                            }
+                        else:
+                            return results, {
+                                "error": repr(e),
+                                "error_code": -4,
+                                "error_message": "Runtime Error",
+                                "inputs": raw_inputs,
+                                "expected": raw_outputs,
+                            }
+                    signal.alarm(0)
+                raw_true_output = output[0]
+                raw_true_output_copy = truncatefn(raw_true_output, 200)
+                output = raw_true_output.splitlines()
+                if not passed:
+                    if debug:
+                        nl = "\n"
+                        if not isinstance(inputs, list):
+                            print(
+                                f"not passed output = {output}, test outputs = {in_outs['outputs'][index]}, inputs = {inputs.replace(nl,' new-line ')}, {type(inputs)}, {output == [in_outs['outputs'][index]]}"
+                            )
+                        else:
+                            print(
+                                f"not passed output = {output}, test outputs = {in_outs['outputs'][index]}, inputs = {inputs}, {type(inputs)}, {output == [in_outs['outputs'][index]]}"
+                            )
+                    continue
+
+                if passed and debug:
+                    print(
+                        f"==> output = {output}, test outputs = {in_outs['outputs'][index]}"
+                    )
+
+                if custom_compare_(output, in_outs["outputs"][index]):
+                    tmp_result = True
+                    results.append(tmp_result)
+                    continue
+
+                # ground truth sequences are expressed as lists not tuples
+                if isinstance(output, tuple):
+                    output = list(output)
+
+                tmp_result = False
+                try:
+                    tmp_result = output == [in_outs["outputs"][index]]
+                    if isinstance(in_outs["outputs"][index], list):
+                        tmp_result = tmp_result or (output == in_outs["outputs"][index])
+                        if isinstance(output[0], str):
+                            tmp_result = tmp_result or (
+                                [e.strip() for e in output] == in_outs["outputs"][index]
+                            )
+                except Exception as e:
+                    if debug:
+                        print(f"Failed check1 exception = {e}")
+                    pass
+
+                if tmp_result == True:
+                    results.append(tmp_result)
+                    continue
+
+                # try one more time without \n
+                if isinstance(in_outs["outputs"][index], list):
+                    for tmp_index, i in enumerate(in_outs["outputs"][index]):
+                        in_outs["outputs"][index][tmp_index] = i.split("\n")
+                        in_outs["outputs"][index][tmp_index] = [
+                            x.strip() for x in in_outs["outputs"][index][tmp_index] if x
+                        ]
+                else:
+                    in_outs["outputs"][index] = in_outs["outputs"][index].split("\n")
+                    in_outs["outputs"][index] = list(
+                        filter(len, in_outs["outputs"][index])
+                    )
+                    in_outs["outputs"][index] = list(
+                        map(lambda x: x.strip(), in_outs["outputs"][index])
+                    )
+
+                try:
+                    tmp_result = output == [in_outs["outputs"][index]]
+                    if isinstance(in_outs["outputs"][index], list):
+                        tmp_result = tmp_result or (output == in_outs["outputs"][index])
+                except Exception as e:
+                    if debug:
+                        print(f"Failed check2 exception = {e}")
+                    pass
+
+                if tmp_result == True:
+                    results.append(tmp_result)
+                    continue
+
+                # try by converting the output into a split up list too
+                if isinstance(output, list):
+                    output = list(filter(len, output))
+
+                if debug:
+                    nl = "\n"
+                    if not isinstance(inputs, list):
+                        print(
+                            f"@1 output = {output}, test outputs = {in_outs['outputs'][index]}, inputs = {inputs.replace(nl,' new-line ')}, {type(inputs)}, {output == [in_outs['outputs'][index]]} {tmp_result=}"
+                        )
+                    else:
+                        print(
+                            f"@1 output = {output}, test outputs = {in_outs['outputs'][index]}, inputs = {inputs}, {type(inputs)}, {output == [in_outs['outputs'][index]]} {tmp_result=}"
+                        )
+
+                if tmp_result == True:
+                    results.append(tmp_result)
+                    continue
+
+                if debug:
+                    print(f"{tmp_result=} @a")
+
+                try:
+                    tmp_result = output == [in_outs["outputs"][index]]
+                    if isinstance(in_outs["outputs"][index], list):
+                        tmp_result = tmp_result or (output == in_outs["outputs"][index])
+                except Exception as e:
+                    if debug:
+                        print(f"Failed check3 exception = {e}")
+                    pass
+
+                if debug:
+                    print(f"{tmp_result=} @b")
+
+                try:
+                    all_ints = all(
+                        combined_int_check(e1) and combined_int_check(e2)
+                        for e1, e2 in zip(output, in_outs["outputs"][index])
+                    )
+                    if not all_ints:
+                        if debug:
+                            print(
+                                [
+                                    combined_int_check(e1) and combined_int_check(e2)
+                                    for e1, e2 in zip(output, in_outs["outputs"][index])
+                                ]
+                            )
+                        output_float = [float(e) for e in output]
+                        gt_float = [float(e) for e in in_outs["outputs"][index]]
+                        tmp_result = tmp_result or (
+                            (len(output_float) == len(gt_float))
+                            and np.allclose(output_float, gt_float)
+                        )
+                except Exception as e:
+                    pass
+
+                if debug:
+                    print(f"{tmp_result=} @c")
+
+                try:
+                    if isinstance(output[0], list):
+                        all_ints = all(
+                            combined_int_check(e1) and combined_int_check(e2)
+                            for e1, e2 in zip(output[0], in_outs["outputs"][index])
+                        )
+                        if not all_ints:
+                            output_float = [float(e) for e in output[0]]
+                            gt_float = [float(e) for e in in_outs["outputs"][index][0]]
+                            tmp_result = tmp_result or (
+                                (len(output_float) == len(gt_float))
+                                and np.allclose(output_float, gt_float)
+                            )
+                except Exception as e:
+                    pass
+
+                if tmp_result == True:
+                    results.append(tmp_result)
+                    continue
+
+                if debug:
+                    print(f"{tmp_result=} @d")
+                # try by converting the stuff into split up list
+                if isinstance(in_outs["outputs"][index], list):
+                    for tmp_index, i in enumerate(in_outs["outputs"][index]):
+                        in_outs["outputs"][index][tmp_index] = set(i.split())
+                else:
+                    in_outs["outputs"][index] = set(in_outs["outputs"][index].split())
+
+                if debug:
+                    print(f"{tmp_result=} @e")
+
+                try:
+                    tmp_result = output == in_outs["outputs"][index]
+                except Exception as e:
+                    if debug:
+                        print(f"Failed check4 exception = {e}")
+                    continue
+
+                if tmp_result == True:
+                    results.append(tmp_result)
+                    continue
+
+                if debug:
+                    print(f"{tmp_result=} @f")
+
+                # try by converting the output into a split up list too
+                if isinstance(output, list):
+                    for tmp_index, i in enumerate(output):
+                        output[tmp_index] = i.split()
+                    output = list(filter(len, output))
+                    for tmp_index, i in enumerate(output):
+                        output[tmp_index] = set(i)
+                else:
+                    output = output.split()
+                    output = list(filter(len, output))
+                    output = set(output)
+
+                if debug:
+                    print(f"{tmp_result=} @g")
+                # try:
+                #     tmp_result = set(frozenset(s) for s in output) == set(
+                #         frozenset(s) for s in in_outs["outputs"][index]
+                #     )
+                # except Exception as e:
+                #     if debug:
+                #         print(f"Failed check5 exception = {e}")
+
+                # if they are all numbers, round so that similar numbers are treated as identical
+                # try:
+                #     all_ints = all(
+                #         combined_int_check(e1) and combined_int_check(e2)
+                #         for e1, e2 in zip(output, in_outs["outputs"][index])
+                #     )
+                #     tmp_result = tmp_result or (
+                #         set(frozenset(round(float(t), 3) for t in s) for s in output)
+                #         == set(
+                #             frozenset(round(float(t), 3) for t in s)
+                #             for s in in_outs["outputs"][index]
+                #         )
+                #     )
+                # except Exception as e:
+                #     if debug:
+                #         print(f"Failed check6 exception = {e}")
+
+                if debug:
+                    print(f"{tmp_result=} @h")
+
+                if tmp_result == True and debug:
+                    print("PASSED")
+
+                results.append(tmp_result)
+                if tmp_result != True:
+                    return results, {
+                        "output": raw_true_output_copy,
+                        "expected": raw_outputs,
+                        "inputs": raw_inputs,
+                        "error_code": -2,
+                        "error_message": "Wrong Answer",
+                    }
+
+                if debug:
+                    nl = "\n"
+                    if not isinstance(inputs, list):
+                        print(
+                            f"@2 output = {output}, test outputs = {in_outs['outputs'][index]}, inputs = {inputs.replace(nl,' new-line ')}, {type(inputs)}, {output == [in_outs['outputs'][index]]}"
+                        )
+                    else:
+                        print(
+                            f"@2 output = {output}, test outputs = {in_outs['outputs'][index]}, inputs = {inputs}, {type(inputs)}, {output == [in_outs['outputs'][index]]}"
+                        )
+
+                    print(f"results = {results}")
+
+    return results, {}
+
+
+def custom_compare_(output, ground_truth):
+
+    if isinstance(output, list):
+        output_1 = "\n".join(output)
+        if stripped_string_compare(output_1, ground_truth):
+            return True
+
+    if isinstance(output, list):
+        output_2 = [o.lstrip().rstrip() for o in output]
+        output_2 = "\n".join(output_2)
+        if stripped_string_compare(output_2, ground_truth):
+            return True
+
+    return False
+
+
+def stripped_string_compare(s1, s2):
+    s1 = s1.lstrip().rstrip()
+    s2 = s2.lstrip().rstrip()
+    return s1 == s2
+
+
+def call_method(method, inputs):
+
+    if isinstance(inputs, list):
+        inputs = "\n".join(inputs)
+
+    inputs_line_iterator = iter(inputs.split("\n"))
+
+    # sys.setrecursionlimit(10000)
+
+    # @patch('builtins.input', side_effect=inputs.split("\n"))
+    @patch("builtins.open", mock_open(read_data=inputs))
+    @patch("sys.stdin", StringIO(inputs))
+    @patch("sys.stdin.readline", lambda *args: next(inputs_line_iterator))
+    @patch("sys.stdin.readlines", lambda *args: inputs.split("\n"))
+    @patch("sys.stdin.read", lambda *args: inputs)
+    # @patch('sys.stdout.write', print)
+    def _inner_call_method(_method):
+        try:
+            return _method()
+        except SystemExit as e:
+            pass
+        finally:
+            pass
+
+    return _inner_call_method(method)
+
+
+def reliability_guard(maximum_memory_bytes=None):
+    """
+    This disables various destructive functions and prevents the generated code
+    from interfering with the test (e.g. fork bomb, killing other processes,
+    removing filesystem files, etc.)
+    WARNING
+    This function is NOT a security sandbox. Untrusted code, including, model-
+    generated code, should not be blindly executed outside of one. See the
+    Codex paper for more information about OpenAI's code sandbox, and proceed
+    with caution.
+    """
+
+    if maximum_memory_bytes is not None:
+        import resource
+
+        resource.setrlimit(
+            resource.RLIMIT_AS, (maximum_memory_bytes, maximum_memory_bytes)
+        )
+        resource.setrlimit(
+            resource.RLIMIT_DATA, (maximum_memory_bytes, maximum_memory_bytes)
+        )
+        if not platform.uname().system == "Darwin":
+            resource.setrlimit(
+                resource.RLIMIT_STACK, (maximum_memory_bytes, maximum_memory_bytes)
+            )
+
+    faulthandler.disable()
+
+    import builtins
+
+    builtins.exit = None
+    builtins.quit = None
+
+    import os
+
+    os.environ["OMP_NUM_THREADS"] = "1"
+
+    os.kill = None
+    os.system = None
+    os.putenv = None
+    os.remove = None
+    os.removedirs = None
+    os.rmdir = None
+    os.fchdir = None
+    os.setuid = None
+    os.fork = None
+    os.forkpty = None
+    os.killpg = None
+    os.rename = None
+    os.renames = None
+    os.truncate = None
+    os.replace = None
+    os.unlink = None
+    os.fchmod = None
+    os.fchown = None
+    os.chmod = None
+    os.chown = None
+    os.chroot = None
+    os.fchdir = None
+    os.lchflags = None
+    os.lchmod = None
+    os.lchown = None
+    os.getcwd = None
+    os.chdir = None
+
+    import shutil
+
+    shutil.rmtree = None
+    shutil.move = None
+    shutil.chown = None
+
+    import subprocess
+
+    subprocess.Popen = None  # type: ignore
+
+    __builtins__["help"] = None
+
+    import sys
+
+    sys.modules["ipdb"] = None
+    sys.modules["joblib"] = None
+    sys.modules["resource"] = None
+    sys.modules["psutil"] = None
+    sys.modules["tkinter"] = None
+'''
+
+TEST_CODE = """
+import json
+import sys
+
+from testing_util import run_test
+
+with open('test_cases.txt', 'r') as fin:
+    sample = json.load(fin)
+with open('code.py', 'r') as fin:
+    code = fin.read()
+
+result, metadata = run_test(sample, code, debug=False, timeout=%(timeout)s)
+if any(x != True for x in result):
+    print(metadata)
+    sys.exit(-1)
+else:
+    sys.exit(0)
+"""
+
+LCB_SYSTEM_MESSAGE_GENERIC = "You are an expert Python programmer. You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests."
+LCB_FORMATTING_MESSAGE_WITH_STARTER_CODE = "You will use the following starter code to write the solution to the problem and enclose your code within delimiters."
+LCB_FORMATTING_WITHOUT_STARTER_CODE = "Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within delimiters as follows. Ensure that when the python program runs, it reads the inputs, runs the algorithm and writes output to STDOUT."
+
+
+def fetch_live_code_bench_system_prompt(prompt: str, starter_code: str | None = None) -> str:
+    """
+    Build the standard LiveCodeBench system prompt, optionally injecting starter code.
+    """
+    prompt = LCB_SYSTEM_MESSAGE_GENERIC + "\n\n" + prompt
+    if starter_code:
+        prompt += f"### Format: {LCB_FORMATTING_MESSAGE_WITH_STARTER_CODE}\n"
+        prompt += f"```python\n{starter_code}\n```\n\n"
+    else:
+        prompt += f"### Format: {LCB_FORMATTING_WITHOUT_STARTER_CODE}\n"
+        prompt += "```python\n# YOUR CODE HERE\n```\n\n"
+    prompt += "### Answer: (use the provided format with backticks)\n\n"
+    return prompt
diff --git a/tinker_cookbook/recipes/code_rl/sandbox_config/local.yaml b/tinker_cookbook/recipes/code_rl/sandbox_config/local.yaml
new file mode 100644
index 0000000..c2ac644
--- /dev/null
+++ b/tinker_cookbook/recipes/code_rl/sandbox_config/local.yaml
@@ -0,0 +1,122 @@
+dataset:
+  database:
+    backend:
+      type: none
+    cache:
+      path: memory
+      sources:
+        - type: local
+          path: sandbox/tests/datasets/samples
+  max_runner_concurrency: 32
+  default_dataset_table: code_eval_${dataset_id}
+  registry:
+    - module_path: sandbox.datasets.aider_benchmark
+      class_name: AiderBenchmarkDataset
+      dataset_tables:
+        aider_benchmark_v1: code_eval_aider_benchmark_v1
+    - module_path: sandbox.datasets.autoeval
+      class_name: AutoEvalDataset
+    - module_path: sandbox.datasets.common_oj
+      class_name: CommonOJDataset
+      dataset_tables:
+        code_contests: code_eval_code_contests
+    - module_path: sandbox.datasets.cruxeval
+      class_name: CruxEvalDataset
+      dataset_tables:
+        cruxeval: code_eval_cruxeval
+        cruxeval_x: code_eval_cruxeval_x
+    - module_path: sandbox.datasets.multiple
+      class_name: MultiPLEDataset
+      dataset_tables:
+        multiple_cpp: code_eval_multiple_cpp
+        multiple_ts: code_eval_multiple_ts
+        multiple_sh: code_eval_multiple_sh
+        multiple_cs: code_eval_multiple_cs
+        multiple_go: code_eval_multiple_go
+        multiple_java: code_eval_multiple_java
+        multiple_lua: code_eval_multiple_lua
+        multiple_js: code_eval_multiple_js
+        multiple_php: code_eval_multiple_php
+        multiple_pl: code_eval_multiple_pl
+        multiple_rkt: code_eval_multiple_rkt
+        multiple_r: code_eval_multiple_r
+        multiple_rs: code_eval_multiple_re
+        multiple_scala: code_eval_multiple_scala
+        multiple_swift: code_eval_multiple_swift
+        multiple_rb: code_eval_multiple_rb
+        multiple_d: code_eval_multiple_d
+        multiple_jl: code_eval_multiple_jl
+    - module_path: sandbox.datasets.humaneval
+      class_name: HumanEvalDataset
+      dataset_tables:
+        humaneval_python: code_eval_humaneval_python
+        humaneval_cpp: code_eval_humaneval_cpp
+        humaneval_typescript: code_eval_humaneval_typescript
+        humaneval_bash: code_eval_humaneval_bash
+        humaneval_csharp: code_eval_humaneval_csharp
+        humaneval_go: code_eval_humaneval_go
+        humaneval_java: code_eval_humaneval_java
+        shadow_humaneval_python: code_eval_shadow_humaneval_python
+        bigcodebench: code_eval_bigcodebench
+    - module_path: sandbox.datasets.humanevoeval
+      class_name: EvoEvalDataset
+      dataset_tables:
+        evoeval: code_eval_EvoEval
+    - module_path: sandbox.datasets.live_code_bench
+      class_name: LiveCodeBenchDataset
+      dataset_tables:
+        live_code_bench_v1: code_eval_live_code_bench_v1
+    - module_path: sandbox.datasets.mbpp
+      class_name: MBPPDataset
+      dataset_tables:
+        mbpp: code_eval_mbpp
+    - module_path: sandbox.datasets.mbxp
+      class_name: MBXPDataset
+      dataset_tables:
+        mbxp_v1_en: code_eval_mbxp_v1_en
+        humanevalds_v1_en: code_eval_humanevalds_v1_en
+        oodtest_v1_zh: code_eval_oodtest_v1_zh
+        humanevalds_v2_en: code_eval_humanevalds_v2_en
+        mbxp_v2_en: code_eval_mbxp_v2_en
+    - module_path: sandbox.datasets.mhpp
+      class_name: MHPPDataset
+      dataset_tables:
+        mhpp: code_eval_mhpp
+    - module_path: sandbox.datasets.minif2f
+      class_name: MiniF2FLean4Dataset
+      dataset_tables:
+        minif2f_lean4_test: code_eval_minif2f_lean4_test
+        minif2f_lean4_valid: code_eval_minif2f_lean4_valid
+    - module_path: sandbox.datasets.natural_code_bench
+      class_name: NaturalCodeBenchDataset
+      dataset_tables:
+        ncb_python_zh: code_eval_ncb_python_zh
+        ncb_python_en: code_eval_ncb_python_en
+        ncb_java_zh: code_eval_ncb_java_zh
+        ncb_java_en: code_eval_ncb_java_en
+    - module_path: sandbox.datasets.palmath
+      class_name: PalMathDataset
+      dataset_tables:
+        palmath: code_eval_palmath
+    - module_path: sandbox.datasets.repobench_c
+      class_name: RepobenchCDataset
+      dataset_tables:
+        repobench_c_python: code_eval_repobench_c_python_sampled
+        repobench_c_java: code_eval_repobench_c_java_sampled
+    - module_path: sandbox.datasets.repobench_p
+      class_name: RepobenchPDataset
+      dataset_tables:
+        repobench_p_python: code_eval_repobench_p_python_sampled
+        repobench_p_java: code_eval_repobench_p_java_sampled
+    - module_path: sandbox.datasets.verilog
+      class_name: VerilogDataset
+      dataset_tables:
+        verilogeval_human: code_eval_verilogeval_human
+        verilogeval_machine: code_eval_verilogeval_machine
+sandbox:
+  isolation: none
+  cleanup_process: false
+  restore_bash: false
+  max_concurrency: 34
+common:
+  logging_color: true
diff --git a/tinker_cookbook/recipes/code_rl/train.py b/tinker_cookbook/recipes/code_rl/train.py
new file mode 100644
index 0000000..6bcab08
--- /dev/null
+++ b/tinker_cookbook/recipes/code_rl/train.py
@@ -0,0 +1,112 @@
+import asyncio
+import logging
+from datetime import datetime
+
+import chz
+from tinker_cookbook import cli_utils, model_info
+from tinker_cookbook.recipes.code_rl.code_env import DeepcoderDatasetBuilder
+from tinker_cookbook.rl.train import AsyncConfig, Config, main
+
+logger = logging.getLogger(__name__)
+
+
+@chz.chz
+class CLIConfig:
+    """Command-line configuration for DeepCoder RL training."""
+
+    # Model configuration
+    model_name: str = "meta-llama/Llama-3.1-8B-Instruct"
+    lora_rank: int = 32
+    renderer_name: str | None = None
+    load_checkpoint_path: str | None = None
+
+    # Data / environment configuration
+    seed: int = 0
+
+    # Training hyperparameters
+    group_size: int = 4
+    groups_per_batch: int = 100
+    learning_rate: float = 1e-5
+    max_tokens: int = 5
+    kl_penalty_coef: float = 0.0
+    num_substeps: int = 1
+
+    # Logging / eval / checkpoints
+    log_dir: str | None = None
+    log_path: str | None = None
+    wandb_project: str | None = None
+    wandb_name: str | None = None
+    compute_post_kl: bool = False
+    eval_every: int = 20
+    save_every: int = 20
+
+    # Service configuration
+    base_url: str | None = None
+
+    behavior_if_log_dir_exists: cli_utils.LogdirBehavior = "ask"
+
+    # Async rollout configuration
+    max_steps_off_policy: int | None = None
+
+
+async def cli_main(cli_config: CLIConfig) -> None:
+    renderer_name = cli_config.renderer_name or model_info.get_recommended_renderer_name(
+        cli_config.model_name
+    )
+
+    model_tag = cli_config.model_name.replace("/", "-")
+    run_name = (
+        f"deepcoder-{model_tag}-{cli_config.lora_rank}rank-"
+        f"{cli_config.learning_rate}lr-{cli_config.group_size}group-"
+        f"{cli_config.groups_per_batch}batch-seed{cli_config.seed}-"
+        f"{datetime.now().strftime('%Y-%m-%d-%H-%M')}"
+    )
+
+    # Set log path
+    if cli_config.log_path is not None:
+        log_path = cli_config.log_path
+    else:
+        log_path = f"/tmp/tinker-examples/code_rl/{run_name}"
+
+    wandb_name = cli_config.wandb_name or run_name
+
+    dataset_builder = DeepcoderDatasetBuilder(
+        batch_size=cli_config.groups_per_batch,
+        model_name_for_tokenizer=cli_config.model_name,
+        renderer_name=renderer_name,
+        group_size=cli_config.group_size,
+        seed=cli_config.seed,
+    )
+
+    config = Config(
+        learning_rate=cli_config.learning_rate,
+        dataset_builder=dataset_builder,
+        model_name=cli_config.model_name,
+        lora_rank=cli_config.lora_rank,
+        max_tokens=cli_config.max_tokens,
+        wandb_project=cli_config.wandb_project,
+        wandb_name=wandb_name,
+        log_path=log_path,
+        base_url=cli_config.base_url,
+        load_checkpoint_path=cli_config.load_checkpoint_path,
+        compute_post_kl=cli_config.compute_post_kl,
+        kl_penalty_coef=cli_config.kl_penalty_coef,
+        num_substeps=cli_config.num_substeps,
+        eval_every=cli_config.eval_every,
+        save_every=cli_config.save_every,
+        async_config=AsyncConfig(
+            max_steps_off_policy=cli_config.max_steps_off_policy,
+            groups_per_batch=cli_config.groups_per_batch,
+        )
+        if cli_config.max_steps_off_policy is not None
+        else None,
+    )
+
+    cli_utils.check_log_dir(log_path, behavior_if_exists=cli_config.behavior_if_log_dir_exists)
+
+    await main(config)
+
+
+if __name__ == "__main__":
+    cli_config = chz.entrypoint(CLIConfig)
+    asyncio.run(cli_main(cli_config))