diff --git a/src/core/containers/runtime/providers.py b/src/core/containers/runtime/providers.py
index a8022ddc..829844bf 100644
--- a/src/core/containers/runtime/providers.py
+++ b/src/core/containers/runtime/providers.py
@@ -138,26 +138,39 @@ def start_container(
             port: Port to expose (if None, finds available port)
             env_vars: Environment variables for the container
             **kwargs: Additional Docker run options
+                - memory_gb: Memory limit in GB (default: 4GB)
+                - command_override: List of command args to override container CMD
 
         Returns:
             Base URL to connect to the container
         """
         import subprocess
         import time
+        import logging
+
+        logger = logging.getLogger(__name__)
 
         # Find available port if not specified
         if port is None:
             port = self._find_available_port()
 
+        # Use default memory limit if not specified
+        memory_gb = kwargs.get("memory_gb", 16)
+
         # Generate container name
         self._container_name = self._generate_container_name(image)
 
         # Build docker run command
+        # Use host networking for better performance and consistency with podman
+        # NOTE: Do NOT use --rm initially - if container fails to start, we need logs
         cmd = [
             "docker", "run",
             "-d",  # Detached
             "--name", self._container_name,
-            "-p", f"{port}:8000",  # Map port
+            "--network", "host",  # Use host network
+            "--memory", f"{memory_gb}g",  # Limit container memory
+            "--memory-swap", f"{memory_gb}g",  # Prevent swap usage (set equal to --memory)
+            "--oom-kill-disable=false",  # Allow OOM killer (exit gracefully)
         ]
 
         # Add environment variables
@@ -165,13 +178,24 @@ def start_container(
             for key, value in env_vars.items():
                 cmd.extend(["-e", f"{key}={value}"])
 
+        # Pass custom port via environment variable instead of overriding command
+        # This allows the container to use its proper entrypoint/CMD
+        if port != 8000:
+            cmd.extend(["-e", f"PORT={port}"])
+
         # Add image
         cmd.append(image)
+          
+        # Add command override if provided (explicit override by user)
+        if "command_override" in kwargs:
+            cmd.extend(kwargs["command_override"])
 
         # Run container
         try:
+            logger.debug(f"Starting container with command: {' '.join(cmd)}")
             result = subprocess.run(cmd, capture_output=True, text=True, check=True)
             self._container_id = result.stdout.strip()
+            logger.debug(f"Container started with ID: {self._container_id}")
         except subprocess.CalledProcessError as e:
             error_msg = f"Failed to start Docker container.\nCommand: {' '.join(cmd)}\nExit code: {e.returncode}\nStderr: {e.stderr}\nStdout: {e.stdout}"
             raise RuntimeError(error_msg) from e
@@ -179,7 +203,7 @@ def start_container(
         # Wait a moment for container to start
         time.sleep(1)
 
-        base_url = f"http://localhost:{port}"
+        base_url = f"http://127.0.0.1:{port}"
         return base_url
 
     def stop_container(self) -> None:
@@ -227,23 +251,65 @@ def wait_for_ready(self, base_url: str, timeout_s: float = 30.0) -> None:
         """
         import time
         import requests
+        import subprocess
+        import logging
 
         start_time = time.time()
         health_url = f"{base_url}/health"
+        last_error = None
 
         while time.time() - start_time < timeout_s:
             try:
                 response = requests.get(health_url, timeout=2.0)
                 if response.status_code == 200:
                     return
-            except requests.RequestException:
-                pass
+            except requests.RequestException as e:
+                last_error = str(e)
 
             time.sleep(0.5)
 
-        raise TimeoutError(
-            f"Container at {base_url} did not become ready within {timeout_s}s"
-        )
+        # If we timeout, provide diagnostic information
+        error_msg = f"Container at {base_url} did not become ready within {timeout_s}s"
+          
+        if self._container_id:
+            try:
+                # First check if container exists
+                inspect_result = subprocess.run(
+                    ["docker", "inspect", self._container_id],
+                    capture_output=True,
+                    text=True,
+                    timeout=5,
+                )
+                  
+                if inspect_result.returncode != 0:
+                    # Container doesn't exist - likely exited and auto-removed due to --rm flag
+                    error_msg += f"\n\nContainer was auto-removed (likely exited immediately)."
+                    error_msg += f"\nThis typically means:"
+                    error_msg += f"\n  1. The container image has an error in its startup script"
+                    error_msg += f"\n  2. Required dependencies are missing in the container"
+                    error_msg += f"\n  3. Port {base_url.split(':')[-1]} might be in use by another process"
+                    error_msg += f"\n  4. Container command/entrypoint is misconfigured"
+                    error_msg += f"\nTry running the container manually to debug:"
+                    error_msg += f"\n  docker run -it --rm <IMAGE_NAME>"
+                else:
+                    # Container exists, try to get logs
+                    result = subprocess.run(
+                        ["docker", "logs", "--tail", "50", self._container_id],
+                        capture_output=True,
+                        text=True,
+                        timeout=5,
+                    )
+                    if result.stdout or result.stderr:
+                        error_msg += f"\n\nContainer logs (last 50 lines):\n{result.stdout}\n{result.stderr}"
+            except subprocess.TimeoutExpired:
+                error_msg += f"\n\nTimeout while trying to inspect container"
+            except Exception as e:
+                error_msg += f"\n\nFailed to get container diagnostics: {e}"
+
+        if last_error:
+            error_msg += f"\n\nLast connection error: {last_error}"
+
+        raise TimeoutError(error_msg)
 
     def _find_available_port(self) -> int:
         """
diff --git a/src/core/http_env_client.py b/src/core/http_env_client.py
index 16bbfa5d..fcce4d6a 100644
--- a/src/core/http_env_client.py
+++ b/src/core/http_env_client.py
@@ -96,14 +96,18 @@ def from_docker_image(
         if provider is None:
             provider = LocalDockerProvider()
 
+        # Extract timeout_s from kwargs for wait_for_ready, with a default
+        timeout_s = kwargs.pop('timeout_s', 30.0)
+        request_timeout_s = kwargs.pop('request_timeout_s', 15.0)
+
         # 1. Start container with optional kwargs (e.g., env_vars, port)
         base_url = provider.start_container(image, **kwargs)
 
-        # 2. Wait for server to be ready
-        provider.wait_for_ready(base_url)
+        # 2. Wait for server to be ready with the specified timeout
+        provider.wait_for_ready(base_url, timeout_s=timeout_s)
 
-        # 3. Create and return client instance with provider reference
-        return cls(base_url=base_url, provider=provider)
+        # 3. Create and return client instance with provider reference and request timeout
+        return cls(base_url=base_url, request_timeout_s=request_timeout_s, provider=provider)
 
     @classmethod
     def from_hub(cls: Type[EnvClientT], repo_id: str, provider: Optional["ContainerProvider"] = None, **kwargs: Any) -> EnvClientT:
diff --git a/src/core/tools/__init__.py b/src/core/tools/__init__.py
index 034e7f06..fdb681b6 100644
--- a/src/core/tools/__init__.py
+++ b/src/core/tools/__init__.py
@@ -8,9 +8,12 @@
 
 from .git_server_client import GitServerClient, RepoInfo
 from .local_python_executor import PyExecutor
+from .local_julia_executor import JuliaExecutor
+
 
 __all__ = [
     "PyExecutor",
+    "JuliaExecutor",
     "GitServerClient",
     "RepoInfo",
-]
\ No newline at end of file
+]
diff --git a/src/core/tools/julia_process_pool.py b/src/core/tools/julia_process_pool.py
new file mode 100644
index 00000000..86d06a40
--- /dev/null
+++ b/src/core/tools/julia_process_pool.py
@@ -0,0 +1,509 @@
+# Copyright (c) Yogesh Singla and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+Julia Process Pool for high-performance code execution.
+
+This module provides a pool of persistent Julia processes that can be reused
+for multiple code executions, eliminating the overhead of spawning new processes.
+
+Expected speedup: 50-100x for repeated executions compared to spawning new processes.
+
+Features:
+- Persistent Julia processes (no startup overhead)
+- Thread-safe process allocation
+- Automatic recovery from process failures
+- Proper cleanup on shutdown
+- Timeout handling per execution
+
+Example:
+    >>> pool = JuliaProcessPool(size=4, timeout=30)
+    >>> result = pool.execute("println('Hello, Julia!')")
+    >>> print(result.stdout)  # "Hello, Julia!\n"
+    >>> pool.shutdown()  # Clean up all processes
+"""
+
+import atexit
+import logging
+import os
+import subprocess
+import threading
+import time
+from collections import deque
+from pathlib import Path
+from typing import Optional
+
+from core.env_server.types import CodeExecResult
+
+# Setup logging
+logger = logging.getLogger(__name__)
+
+
+class JuliaWorkerProcess:
+    """
+    Single Julia worker process that can execute code repeatedly.
+
+    This class manages communication with a persistent Julia REPL process
+    using a delimiter-based protocol.
+    """
+
+    # Communication protocol delimiters
+    START_OUTPUT = "<<<START_OUTPUT>>>"
+    START_ERROR = "<<<START_ERROR>>>"
+    EXIT_CODE_PREFIX = "<<<EXIT_CODE:"
+    END_EXECUTION = "<<<END_EXECUTION>>>"
+    END_CODE = "<<<END_CODE>>>"
+
+    def __init__(
+        self,
+        worker_id: int,
+        julia_path: str,
+        worker_script: str,
+        optimization_flags: bool = True,
+    ):
+        """
+        Initialize a Julia worker process.
+
+        Args:
+            worker_id: Unique identifier for this worker
+            julia_path: Path to Julia executable
+            worker_script: Path to julia_repl_worker.jl script
+            optimization_flags: Enable Julia optimization flags
+        """
+        self.worker_id = worker_id
+        self.julia_path = julia_path
+        self.worker_script = worker_script
+        self.optimization_flags = optimization_flags
+        self.process: Optional[subprocess.Popen] = None
+        self.is_busy = False
+        self.is_healthy = True
+        self.lock = threading.Lock()
+
+        # Start the worker process
+        self._start_process()
+
+    def _start_process(self) -> None:
+        """Start the Julia worker process."""
+        cmd = [self.julia_path]
+
+        if self.optimization_flags:
+            cmd.extend(
+                [
+                    "--compile=min",
+                    "--optimize=2",
+                    "--startup-file=no",
+                    "--history-file=no",
+                ]
+            )
+
+        cmd.append(self.worker_script)
+
+        try:
+            self.process = subprocess.Popen(
+                cmd,
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                bufsize=1,  # Line buffered
+            )
+
+            # Wait for "Julia worker ready" message on stderr
+            ready_msg = self.process.stderr.readline()
+            if "ready" not in ready_msg.lower():
+                raise RuntimeError(
+                    f"Worker {self.worker_id} did not start properly: {ready_msg}"
+                )
+
+            self.is_healthy = True
+            logger.info(f"Worker {self.worker_id} started (PID: {self.process.pid})")
+
+        except Exception as e:
+            self.is_healthy = False
+            logger.error(f"Failed to start worker {self.worker_id}: {e}")
+            raise
+
+    def execute(self, code: str, timeout: int = 60) -> CodeExecResult:
+        """
+        Execute Julia code in this worker process.
+
+        Args:
+            code: Julia code to execute
+            timeout: Maximum execution time in seconds
+
+        Returns:
+            CodeExecResult with stdout, stderr, and exit_code
+        """
+        with self.lock:
+            if not self.is_healthy or self.process is None:
+                raise RuntimeError(f"Worker {self.worker_id} is not healthy")
+
+            self.is_busy = True
+
+            try:
+                # Send code to worker
+                self.process.stdin.write(code + "\n")
+                self.process.stdin.write(self.END_CODE + "\n")
+                self.process.stdin.flush()
+
+                # Read response with timeout
+                start_time = time.time()
+                stdout_lines = []
+                stderr_lines = []
+                exit_code = -1
+
+                current_section = None  # Track which section we're reading
+
+                while True:
+                    # Check timeout
+                    if time.time() - start_time > timeout:
+                        logger.error(f"Worker {self.worker_id} execution timed out")
+                        self.is_healthy = False
+                        self._kill_process()
+                        return CodeExecResult(
+                            stdout="",
+                            stderr=f"Execution timed out after {timeout} seconds",
+                            exit_code=-1,
+                        )
+
+                    # Read line with timeout (use select for non-blocking read on Unix)
+                    try:
+                        line = self.process.stdout.readline()
+
+                        if not line:
+                            # EOF - process died
+                            logger.error(f"Worker {self.worker_id} died unexpectedly")
+                            self.is_healthy = False
+                            return CodeExecResult(
+                                stdout="".join(stdout_lines),
+                                stderr="Worker process died unexpectedly",
+                                exit_code=-1,
+                            )
+
+                        line = line.rstrip("\n")
+
+                        # Check for delimiters
+                        if line == self.START_OUTPUT:
+                            current_section = "stdout"
+                            continue
+                        elif line == self.START_ERROR:
+                            current_section = "stderr"
+                            continue
+                        elif line.startswith(self.EXIT_CODE_PREFIX):
+                            # Parse exit code
+                            exit_code_str = line[
+                                len(self.EXIT_CODE_PREFIX) : -3
+                            ]  # Remove prefix and ">>>"
+                            exit_code = int(exit_code_str)
+                            continue
+                        elif line == self.END_EXECUTION:
+                            # Execution complete
+                            break
+
+                        # Accumulate output
+                        if current_section == "stdout":
+                            stdout_lines.append(line)
+                        elif current_section == "stderr":
+                            stderr_lines.append(line)
+
+                    except Exception as e:
+                        logger.error(f"Error reading from worker {self.worker_id}: {e}")
+                        self.is_healthy = False
+                        return CodeExecResult(
+                            stdout="".join(stdout_lines),
+                            stderr=f"Error reading from worker: {str(e)}",
+                            exit_code=-1,
+                        )
+
+                # Reconstruct output (add newlines back)
+                stdout_str = "\n".join(stdout_lines) + ("\n" if stdout_lines else "")
+                stderr_str = "\n".join(stderr_lines) + ("\n" if stderr_lines else "")
+
+                return CodeExecResult(
+                    stdout=stdout_str,
+                    stderr=stderr_str,
+                    exit_code=exit_code,
+                )
+
+            finally:
+                self.is_busy = False
+
+    def _kill_process(self) -> None:
+        """Kill the worker process."""
+        if self.process is not None:
+            try:
+                self.process.terminate()
+                self.process.wait(timeout=2.0)
+            except:
+                try:
+                    self.process.kill()
+                    self.process.wait(timeout=1.0)
+                except:
+                    pass
+
+    def shutdown(self) -> None:
+        """Shutdown the worker process gracefully."""
+        with self.lock:
+            if self.process is not None:
+                logger.info(f"Shutting down worker {self.worker_id}")
+                self._kill_process()
+                self.process = None
+                self.is_healthy = False
+
+
+class JuliaProcessPool:
+    """
+    Pool of persistent Julia processes for high-performance code execution.
+
+    This class manages multiple Julia worker processes and distributes
+    code execution among them, providing significant speedup by eliminating
+    process startup overhead.
+
+    Thread-safe for concurrent access from multiple threads.
+
+    Example:
+        >>> pool = JuliaProcessPool(size=4)
+        >>>
+        >>> # Execute code
+        >>> result = pool.execute("println('Hello')")
+        >>>
+        >>> # Pool automatically manages workers
+        >>> results = [pool.execute(f"println({i})") for i in range(100)]
+        >>>
+        >>> # Cleanup when done
+        >>> pool.shutdown()
+    """
+
+    def __init__(
+        self,
+        size: int = 4,
+        timeout: int = 60,
+        julia_path: Optional[str] = None,
+        optimization_flags: bool = True,
+        auto_recover: bool = True,
+    ):
+        """
+        Initialize the Julia process pool.
+
+        Args:
+            size: Number of worker processes to create (default: 4)
+            timeout: Default timeout for code execution in seconds (default: 60)
+            julia_path: Path to Julia executable (auto-detected if None)
+            optimization_flags: Enable Julia optimization flags (default: True)
+            auto_recover: Automatically restart failed workers (default: True)
+
+        Raises:
+            RuntimeError: If Julia executable is not found
+        """
+        self.size = size
+        self.timeout = timeout
+        self.optimization_flags = optimization_flags
+        self.auto_recover = auto_recover
+
+        # Find Julia executable
+        if julia_path is None:
+            julia_path = self._find_julia_executable()
+
+        self.julia_path = julia_path
+
+        # Find worker script
+        self.worker_script = self._find_worker_script()
+
+        # Initialize workers
+        self.workers: list[JuliaWorkerProcess] = []
+        self.available_workers: deque[JuliaWorkerProcess] = deque()
+        self.pool_lock = threading.Lock()
+        self.shutdown_flag = False
+
+        # Create worker processes
+        logger.info(f"Creating Julia process pool with {size} workers")
+        for i in range(size):
+            try:
+                worker = JuliaWorkerProcess(
+                    worker_id=i,
+                    julia_path=self.julia_path,
+                    worker_script=self.worker_script,
+                    optimization_flags=self.optimization_flags,
+                )
+                self.workers.append(worker)
+                self.available_workers.append(worker)
+            except Exception as e:
+                logger.error(f"Failed to create worker {i}: {e}")
+                # Clean up partially created pool
+                self.shutdown()
+                raise RuntimeError(f"Failed to create worker pool: {e}")
+
+        logger.info(f"Julia process pool initialized with {len(self.workers)} workers")
+
+        # Register cleanup on exit
+        atexit.register(self.shutdown)
+
+    def _find_julia_executable(self) -> str:
+        """Find Julia executable in PATH or common locations."""
+        # Try PATH first
+        julia_path = os.popen("which julia").read().strip()
+        if julia_path:
+            return julia_path
+
+        # Try common locations
+        common_paths = [
+            os.path.expanduser("~/.juliaup/bin/julia"),
+            os.path.expanduser("~/.julia/bin/julia"),
+            "/usr/local/bin/julia",
+            "/usr/bin/julia",
+        ]
+
+        for path in common_paths:
+            if os.path.isfile(path) and os.access(path, os.X_OK):
+                return path
+
+        raise RuntimeError(
+            "Julia executable not found. Please install Julia: "
+            "https://julialang.org/downloads/"
+        )
+
+    def _find_worker_script(self) -> str:
+        """Find the julia_repl_worker.jl script."""
+        # Try relative to this file
+        this_dir = Path(__file__).parent
+        worker_script = this_dir / "julia_repl_worker.jl"
+
+        if worker_script.exists():
+            return str(worker_script)
+
+        raise RuntimeError(
+            f"Worker script not found at {worker_script}. "
+            "Please ensure julia_repl_worker.jl is in the same directory."
+        )
+
+    def _get_available_worker(
+        self, timeout: float = 30.0
+    ) -> Optional[JuliaWorkerProcess]:
+        """
+        Get an available worker from the pool.
+
+        Args:
+            timeout: Maximum time to wait for a worker (seconds)
+
+        Returns:
+            Available worker or None if timeout
+        """
+        start_time = time.time()
+
+        while time.time() - start_time < timeout:
+            with self.pool_lock:
+                # Try to get healthy worker
+                while self.available_workers:
+                    worker = self.available_workers.popleft()
+
+                    if worker.is_healthy:
+                        return worker
+
+                    # Worker is unhealthy, try to recover
+                    if self.auto_recover and not self.shutdown_flag:
+                        logger.warning(
+                            f"Worker {worker.worker_id} is unhealthy, attempting recovery"
+                        )
+                        try:
+                            worker.shutdown()
+                            worker = JuliaWorkerProcess(
+                                worker_id=worker.worker_id,
+                                julia_path=self.julia_path,
+                                worker_script=self.worker_script,
+                                optimization_flags=self.optimization_flags,
+                            )
+                            # Update in workers list
+                            self.workers[worker.worker_id] = worker
+                            return worker
+                        except Exception as e:
+                            logger.error(
+                                f"Failed to recover worker {worker.worker_id}: {e}"
+                            )
+
+            # No workers available, wait a bit
+            time.sleep(0.1)
+
+        logger.error("Timeout waiting for available worker")
+        return None
+
+    def _return_worker(self, worker: JuliaWorkerProcess) -> None:
+        """Return a worker to the available pool."""
+        with self.pool_lock:
+            if worker.is_healthy and not self.shutdown_flag:
+                self.available_workers.append(worker)
+
+    def execute(self, code: str, timeout: Optional[int] = None) -> CodeExecResult:
+        """
+        Execute Julia code using an available worker from the pool.
+
+        Args:
+            code: Julia code to execute
+            timeout: Execution timeout in seconds (uses pool default if None)
+
+        Returns:
+            CodeExecResult with stdout, stderr, and exit_code
+        """
+        if self.shutdown_flag:
+            return CodeExecResult(
+                stdout="",
+                stderr="Process pool has been shut down",
+                exit_code=-1,
+            )
+
+        if timeout is None:
+            timeout = self.timeout
+
+        # Get available worker
+        worker = self._get_available_worker()
+
+        if worker is None:
+            return CodeExecResult(
+                stdout="",
+                stderr="No available worker (timeout waiting for worker)",
+                exit_code=-1,
+            )
+
+        try:
+            # Execute code in worker
+            result = worker.execute(code, timeout=timeout)
+            return result
+
+        finally:
+            # Return worker to pool
+            self._return_worker(worker)
+
+    def shutdown(self) -> None:
+        """
+        Shutdown all worker processes gracefully.
+
+        This method is automatically called on exit via atexit.
+        """
+        if self.shutdown_flag:
+            return
+
+        logger.info("Shutting down Julia process pool")
+        self.shutdown_flag = True
+
+        with self.pool_lock:
+            for worker in self.workers:
+                worker.shutdown()
+
+            self.workers.clear()
+            self.available_workers.clear()
+
+        logger.info("Julia process pool shutdown complete")
+
+    def __enter__(self):
+        """Context manager entry."""
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit."""
+        self.shutdown()
+
+    def __del__(self):
+        """Ensure cleanup on garbage collection."""
+        self.shutdown()
diff --git a/src/core/tools/julia_repl_worker.jl b/src/core/tools/julia_repl_worker.jl
new file mode 100644
index 00000000..5cd0a7bb
--- /dev/null
+++ b/src/core/tools/julia_repl_worker.jl
@@ -0,0 +1,159 @@
+#!/usr/bin/env julia
+
+"""
+Julia REPL Worker for Process Pool
+
+This script runs as a persistent Julia process that accepts code via stdin,
+executes it, and returns results via stdout with delimiters.
+
+Protocol:
+- Input: Code block followed by "<<<END_CODE>>>"
+- Output: Results with status markers:
+  - "<<<START_OUTPUT>>>" - stdout begins
+  - "<<<START_ERROR>>>" - stderr begins
+  - "<<<EXIT_CODE:N>>>" - exit code (0 = success, 1 = error)
+  - "<<<END_EXECUTION>>>" - execution complete
+"""
+
+# Delimiters for communication protocol
+const START_OUTPUT = "<<<START_OUTPUT>>>"
+const START_ERROR = "<<<START_ERROR>>>"
+const EXIT_CODE_PREFIX = "<<<EXIT_CODE:"
+const END_EXECUTION = "<<<END_EXECUTION>>>"
+const END_CODE = "<<<END_CODE>>>"
+
+"""
+Execute code and capture output using pipes
+"""
+function execute_code(code::String)
+    # Initialize return values
+    stdout_str = ""
+    stderr_str = ""
+    exit_code = 0
+
+    # Create pipes for output capture
+    out_pipe = Pipe()
+    err_pipe = Pipe()
+
+    try
+        # Execute with output redirected to pipes
+        redirect_stdout(out_pipe) do
+            redirect_stderr(err_pipe) do
+                try
+                    # Execute the code using include_string which properly handles
+                    # multiple statements including 'using' statements
+                    include_string(Main, code)
+                catch e
+                    # Execution error - write to stderr
+                    exit_code = 1
+                    showerror(stderr, e, catch_backtrace())
+                    println(stderr)
+                end
+            end
+        end
+
+        # Close write ends to signal EOF to readers
+        Base.close(out_pipe.in)
+        Base.close(err_pipe.in)
+
+        # Read captured output
+        stdout_str = read(out_pipe.out, String)
+        stderr_str = read(err_pipe.out, String)
+
+        # Close read ends
+        Base.close(out_pipe.out)
+        Base.close(err_pipe.out)
+
+    catch e
+        # Worker error
+        exit_code = 1
+
+        # Try to close pipes
+        try
+            Base.close(out_pipe)
+            Base.close(err_pipe)
+        catch
+        end
+
+        stderr_str = "Worker error: " * sprint(showerror, e)
+    end
+
+    return (stdout_str, stderr_str, exit_code)
+end
+
+"""
+Main loop: read code, execute, return results
+"""
+function main()
+    # Signal that worker is ready
+    println(stderr, "Julia worker ready")
+    flush(stderr)
+
+    while true
+        try
+            # Read code until END_CODE delimiter
+            code_lines = String[]
+
+            while true
+                if eof(stdin)
+                    println(stderr, "Worker received EOF, shutting down")
+                    return
+                end
+
+                line = readline(stdin)
+
+                # Check for end of code
+                if line == END_CODE
+                    break
+                end
+
+                push!(code_lines, line)
+            end
+
+            # If no code received, continue
+            if isempty(code_lines)
+                # Send empty response
+                println(START_OUTPUT)
+                println(START_ERROR)
+                println(EXIT_CODE_PREFIX, 0, ">>>")
+                println(END_EXECUTION)
+                flush(stdout)
+                continue
+            end
+
+            code = join(code_lines, "\n")
+
+            # Execute code and capture output
+            (stdout_str, stderr_str, exit_code) = execute_code(code)
+
+            # Send results with delimiters
+            println(START_OUTPUT)
+            print(stdout_str)
+            flush(stdout)
+
+            println(START_ERROR)
+            print(stderr_str)
+            flush(stdout)
+
+            println(EXIT_CODE_PREFIX, exit_code, ">>>")
+            println(END_EXECUTION)
+            flush(stdout)
+
+        catch e
+            # Worker error - report and continue
+            println(stderr, "Worker error: ", e)
+            flush(stderr)
+
+            # Send error response
+            println(START_OUTPUT)
+            println(START_ERROR)
+            println("Worker internal error: ", e)
+            println(EXIT_CODE_PREFIX, 1, ">>>")
+            println(END_EXECUTION)
+            flush(stdout)
+        end
+    end
+end
+
+# Run main loop
+main()
diff --git a/src/core/tools/local_julia_executor.py b/src/core/tools/local_julia_executor.py
new file mode 100644
index 00000000..ce933200
--- /dev/null
+++ b/src/core/tools/local_julia_executor.py
@@ -0,0 +1,474 @@
+# Copyright (c) Yogesh Singla and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+Local Julia Executor.
+
+This module provides functionality for executing Julia code locally using
+subprocess, similar to PyExecutor.
+
+Features:
+- Proper process cleanup on timeout (no zombie processes)
+- Robust error handling and logging
+- Process group management for complete cleanup
+- Automatic retry on transient failures
+- Optional process pool for 50-100x speedup on repeated executions
+
+Performance Modes:
+- Standard mode: Spawn new process for each execution (default for single executions)
+- Pool mode: Reuse persistent Julia processes (recommended for repeated executions)
+"""
+
+import logging
+import os
+import shutil
+import signal
+import subprocess
+import tempfile
+import threading
+import time
+from pathlib import Path
+from typing import Optional
+
+from core.env_server.types import CodeExecResult
+
+# Try to import process pool (optional dependency)
+try:
+    from core.tools.julia_process_pool import JuliaProcessPool
+
+    POOL_AVAILABLE = True
+except ImportError:
+    POOL_AVAILABLE = False
+    JuliaProcessPool = None
+
+# Setup logging
+logger = logging.getLogger(__name__)
+
+
+class JuliaExecutor:
+    """
+    Executor for running Julia code in a subprocess with robust process management.
+
+    This class provides a safe interface to execute Julia code in isolation
+    and capture the results including stdout, stderr, and exit code.
+
+    Features:
+    - Proper timeout handling without zombie processes
+    - Process group cleanup for nested processes
+    - Automatic retry on transient failures
+    - Comprehensive logging for debugging
+    - Optional process pool for 50-100x speedup on repeated executions
+
+    Example:
+        >>> executor = JuliaExecutor()
+        >>> result = executor.run('println("Hello, Julia!")')
+        >>> print(result.stdout)  # "Hello, Julia!\n"
+        >>> print(result.exit_code)  # 0
+        >>>
+        >>> # With tests
+        >>> code = '''
+        ... function add(a, b)
+        ...     return a + b
+        ... end
+        ...
+        ... using Test
+        ... @test add(2, 3) == 5
+        ... '''
+        >>> result = executor.run(code)
+        >>> print(result.exit_code)  # 0
+        >>>
+        >>> # With process pool (recommended for repeated executions)
+        >>> executor.enable_process_pool(size=4)
+        >>> for i in range(100):
+        ...     result = executor.run(f'println({i})')  # 50-100x faster!
+        >>> executor.shutdown_pool()  # Clean up when done
+    """
+
+    # Class-level process pool (shared across all instances if enabled)
+    _shared_pool: Optional["JuliaProcessPool"] = None
+    _pool_lock = threading.Lock()
+
+    def __init__(
+        self,
+        timeout: int = 60,
+        max_retries: int = 1,
+        use_optimization_flags: bool = True,
+        use_process_pool: bool = False,
+        pool_size: int = 4,
+    ):
+        """
+        Initialize the JuliaExecutor.
+
+        Args:
+            timeout: Maximum execution time in seconds (default: 60)
+            max_retries: Number of retry attempts on transient failures (default: 1)
+            use_optimization_flags: Enable Julia performance flags (default: True)
+            use_process_pool: Enable process pool for better performance (default: False)
+            pool_size: Number of workers in pool if enabled (default: 4)
+
+        Raises:
+            RuntimeError: If Julia executable is not found in PATH
+        """
+        self.timeout = timeout
+        self.max_retries = max_retries
+        self.use_optimization_flags = use_optimization_flags
+        self.use_process_pool = use_process_pool
+        self.pool_size = pool_size
+
+        # Find Julia executable in PATH
+        self.julia_path = shutil.which("julia")
+
+        if not self.julia_path:
+            # Try common installation paths
+            common_paths = [
+                os.path.expanduser("~/.juliaup/bin/julia"),
+                os.path.expanduser("~/.julia/bin/julia"),
+                "/usr/local/bin/julia",
+                "/usr/bin/julia",
+            ]
+
+            for path in common_paths:
+                if os.path.isfile(path) and os.access(path, os.X_OK):
+                    self.julia_path = path
+                    break
+
+        if not self.julia_path:
+            raise RuntimeError(
+                "Julia executable not found in PATH or common locations. "
+                "Please install Julia: https://julialang.org/downloads/ "
+                "or ensure it's in your PATH environment variable."
+            )
+
+        # Build optimized Julia command with performance flags
+        self.base_cmd = [self.julia_path]
+
+        if self.use_optimization_flags:
+            # Performance optimization flags:
+            # --compile=min: Reduce compilation overhead (faster startup)
+            # --optimize=2: Medium optimization level (good balance)
+            # --startup-file=no: Don't load ~/.julia/config/startup.jl
+            # --history-file=no: Don't save REPL history
+            self.base_cmd.extend(
+                [
+                    "--compile=min",  # Minimize compilation for faster startup
+                    "--optimize=2",  # Good optimization level
+                    "--startup-file=no",  # Skip startup file
+                    "--history-file=no",  # Skip history
+                ]
+            )
+
+            logger.info("Julia optimization flags enabled for faster execution")
+
+        logger.info(f"JuliaExecutor initialized with Julia at: {self.julia_path}")
+        logger.info(f"Command: {' '.join(self.base_cmd)}")
+        logger.info(f"Timeout: {self.timeout}s, Max retries: {self.max_retries}")
+
+        # Initialize process pool if requested
+        if self.use_process_pool:
+            self.enable_process_pool(size=self.pool_size)
+
+    def _kill_process_tree(
+        self, proc: subprocess.Popen, script_file: Optional[str] = None
+    ) -> None:
+        """
+        Terminate a process and all its children.
+
+        Args:
+            proc: The subprocess.Popen instance to terminate
+            script_file: Optional script file path to kill if process is stuck
+        """
+        if proc.poll() is None:  # Process is still running
+            try:
+                # Try graceful termination first
+                logger.warning(f"Terminating process {proc.pid} gracefully...")
+                proc.terminate()
+
+                # Wait up to 2 seconds for graceful termination
+                try:
+                    proc.wait(timeout=2.0)
+                    logger.info(f"Process {proc.pid} terminated gracefully")
+                    return
+                except subprocess.TimeoutExpired:
+                    logger.warning(
+                        f"Process {proc.pid} did not terminate, forcing kill..."
+                    )
+
+                # Force kill if still running
+                proc.kill()
+                proc.wait(timeout=2.0)
+                logger.info(f"Process {proc.pid} killed forcefully")
+
+            except Exception as e:
+                logger.error(f"Error killing process {proc.pid}: {e}")
+
+                # Last resort: try killing via process group
+                try:
+                    if hasattr(os, "killpg"):
+                        os.killpg(os.getpgid(proc.pid), signal.SIGKILL)
+                        logger.info(f"Killed process group for {proc.pid}")
+                except Exception as pg_error:
+                    logger.error(f"Failed to kill process group: {pg_error}")
+
+    def run(self, code: str) -> CodeExecResult:
+        """
+        Execute Julia code and return the result with robust error handling.
+
+        This method provides:
+        - Automatic retry on transient failures
+        - Proper timeout handling without zombie processes
+        - Process group cleanup for nested processes
+        - Comprehensive error logging
+        - Optional process pool for 50-100x speedup
+
+        Args:
+            code: Julia code string to execute
+
+        Returns:
+            CodeExecResult containing stdout, stderr, and exit_code
+
+        Example:
+            >>> executor = JuliaExecutor()
+            >>> result = executor.run("x = 5 + 3\\nprintln(x)")
+            >>> print(result.stdout)  # "8\n"
+            >>> print(result.exit_code)  # 0
+            >>>
+            >>> # Error handling
+            >>> result = executor.run("1 / 0")
+            >>> print(result.exit_code)  # 1
+            >>> print(result.stderr)  # Contains error message
+        """
+        # Use process pool if enabled and available
+        if self.use_process_pool and JuliaExecutor._shared_pool is not None:
+            try:
+                return JuliaExecutor._shared_pool.execute(code, timeout=self.timeout)
+            except Exception as e:
+                logger.warning(
+                    f"Process pool execution failed: {e}, falling back to subprocess"
+                )
+                # Fall through to standard execution
+
+        code_file = None
+
+        for attempt in range(self.max_retries + 1):
+            proc = None
+
+            try:
+                # Create temporary file for Julia code
+                with tempfile.NamedTemporaryFile(
+                    mode="w", suffix=".jl", delete=False, encoding="utf-8"
+                ) as f:
+                    f.write(code)
+                    code_file = f.name
+
+                script_name = Path(code_file).name
+                logger.debug(
+                    f"[Attempt {attempt + 1}/{self.max_retries + 1}] Executing Julia script: {script_name}"
+                )
+
+                # Start process with Popen for better control
+                # Use process group to ensure we can kill all child processes
+                start_time = time.time()
+
+                # On Unix systems, use process groups for better cleanup
+                kwargs = {
+                    "stdout": subprocess.PIPE,
+                    "stderr": subprocess.PIPE,
+                    "text": True,
+                }
+
+                # Create new process group on Unix systems
+                if hasattr(os, "setpgrp"):
+                    kwargs["preexec_fn"] = os.setpgrp
+
+                proc = subprocess.Popen(self.base_cmd + [code_file], **kwargs)
+
+                logger.debug(
+                    f"Started Julia process {proc.pid} for script {script_name}"
+                )
+
+                # Wait for process with timeout
+                try:
+                    stdout, stderr = proc.communicate(timeout=self.timeout)
+                    exit_code = proc.returncode
+                    elapsed = time.time() - start_time
+
+                    logger.debug(
+                        f"Julia execution completed in {elapsed:.2f}s (exit code: {exit_code})"
+                    )
+
+                    # Clean up temp file
+                    try:
+                        Path(code_file).unlink()
+                    except Exception as cleanup_error:
+                        logger.debug(
+                            f"Could not delete temp file {code_file}: {cleanup_error}"
+                        )
+
+                    return CodeExecResult(
+                        stdout=stdout,
+                        stderr=stderr,
+                        exit_code=exit_code,
+                    )
+
+                except subprocess.TimeoutExpired:
+                    logger.error(
+                        f"Julia execution timed out after {self.timeout}s (attempt {attempt + 1}/{self.max_retries + 1})"
+                    )
+
+                    # CRITICAL: Kill the process AND all its children to prevent zombies
+                    self._kill_process_tree(proc, code_file)
+
+                    # If this was our last retry, return timeout error
+                    if attempt >= self.max_retries:
+                        logger.error(
+                            f"Julia execution failed permanently after {self.max_retries + 1} timeout attempts"
+                        )
+                        return CodeExecResult(
+                            stdout="",
+                            stderr=f"Execution timed out after {self.timeout} seconds (tried {self.max_retries + 1} times)",
+                            exit_code=-1,
+                        )
+
+                    # Wait before retry
+                    logger.info(f"Waiting 1s before retry...")
+                    time.sleep(1.0)
+                    continue
+
+            except FileNotFoundError:
+                logger.error(f"Julia executable not found at {self.julia_path}")
+                return CodeExecResult(
+                    stdout="",
+                    stderr=f"Julia executable not found: {self.julia_path}",
+                    exit_code=-1,
+                )
+
+            except Exception as e:
+                logger.error(
+                    f"Error executing Julia code (attempt {attempt + 1}/{self.max_retries + 1}): {e}"
+                )
+
+                # Try to kill process if it exists
+                if proc is not None and proc.poll() is None:
+                    self._kill_process_tree(proc, code_file)
+
+                # If this was our last retry, return error
+                if attempt >= self.max_retries:
+                    logger.error(
+                        f"Julia execution failed permanently after {self.max_retries + 1} attempts"
+                    )
+                    return CodeExecResult(
+                        stdout="",
+                        stderr=f"Error executing Julia code: {str(e)}",
+                        exit_code=-1,
+                    )
+
+                # Wait before retry
+                logger.info(f"Waiting 1s before retry...")
+                time.sleep(1.0)
+                continue
+
+            finally:
+                # Always ensure temp file is cleaned up
+                if code_file and Path(code_file).exists():
+                    try:
+                        Path(code_file).unlink()
+                        logger.debug(f"Cleaned up temp file: {code_file}")
+                    except Exception as cleanup_error:
+                        logger.debug(
+                            f"Could not delete temp file {code_file}: {cleanup_error}"
+                        )
+
+        # Should never reach here, but just in case
+        return CodeExecResult(
+            stdout="",
+            stderr="Unexpected error: all retries exhausted",
+            exit_code=-1,
+        )
+
+    @classmethod
+    def enable_process_pool(cls, size: int = 4, timeout: int = 60) -> bool:
+        """
+        Enable the shared Julia process pool for all JuliaExecutor instances.
+
+        This provides 50-100x speedup for repeated code executions by reusing
+        persistent Julia processes instead of spawning new ones.
+
+        Args:
+            size: Number of worker processes to create (default: 4)
+            timeout: Default timeout for code execution in seconds (default: 60)
+
+        Returns:
+            True if pool was created successfully, False otherwise
+
+        Example:
+            >>> JuliaExecutor.enable_process_pool(size=8)
+            >>> executor = JuliaExecutor(use_process_pool=True)
+            >>> # All executors with use_process_pool=True will use the shared pool
+        """
+        if not POOL_AVAILABLE:
+            logger.warning(
+                "Process pool not available (julia_process_pool module not found)"
+            )
+            return False
+
+        with cls._pool_lock:
+            if cls._shared_pool is not None:
+                logger.warning("Process pool already enabled")
+                return True
+
+            try:
+                logger.info(f"Enabling Julia process pool with {size} workers")
+                cls._shared_pool = JuliaProcessPool(size=size, timeout=timeout)
+                logger.info("Julia process pool enabled successfully")
+                return True
+            except Exception as e:
+                logger.error(f"Failed to enable process pool: {e}")
+                return False
+
+    @classmethod
+    def shutdown_pool(cls) -> None:
+        """
+        Shutdown the shared Julia process pool.
+
+        This should be called when you're done with all Julia executions
+        to properly clean up worker processes.
+
+        Example:
+            >>> JuliaExecutor.enable_process_pool()
+            >>> # ... do work ...
+            >>> JuliaExecutor.shutdown_pool()  # Clean up
+        """
+        with cls._pool_lock:
+            if cls._shared_pool is not None:
+                logger.info("Shutting down Julia process pool")
+                cls._shared_pool.shutdown()
+                cls._shared_pool = None
+                logger.info("Julia process pool shutdown complete")
+
+    @classmethod
+    def is_pool_enabled(cls) -> bool:
+        """
+        Check if the process pool is currently enabled.
+
+        Returns:
+            True if pool is enabled, False otherwise
+        """
+        with cls._pool_lock:
+            return cls._shared_pool is not None
+
+    def __enter__(self):
+        """Context manager entry."""
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit."""
+        # Don't shutdown the shared pool when exiting a single executor
+        pass
+
+    def __del__(self):
+        """Cleanup on garbage collection."""
+        # Don't shutdown the shared pool when a single executor is deleted
+        pass
diff --git a/src/envs/julia_env/__init__.py b/src/envs/julia_env/__init__.py
new file mode 100644
index 00000000..556206e8
--- /dev/null
+++ b/src/envs/julia_env/__init__.py
@@ -0,0 +1,13 @@
+# Copyright (c) Yogesh Singla and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""Julia Environment - Code execution environment for RL training."""
+
+from .julia_env_client import JuliaEnv
+from .models import JuliaAction, JuliaObservation, JuliaState
+
+__all__ = ["JuliaAction", "JuliaObservation", "JuliaState", "JuliaEnv"]
+
diff --git a/src/envs/julia_env/julia_env_client.py b/src/envs/julia_env/julia_env_client.py
new file mode 100644
index 00000000..d4fc563b
--- /dev/null
+++ b/src/envs/julia_env/julia_env_client.py
@@ -0,0 +1,117 @@
+# Copyright (c) Yogesh Singla and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+Julia Environment HTTP Client.
+
+This module provides the client for connecting to a Julia Environment server
+over HTTP.
+"""
+
+from typing import Dict
+
+from core.client_types import StepResult
+from core.http_env_client import HTTPEnvClient
+
+from .models import JuliaAction, JuliaObservation, JuliaState
+
+
+class JuliaEnv(HTTPEnvClient[JuliaAction, JuliaObservation]):
+    """
+    HTTP client for the Julia Environment.
+    
+    This client connects to a JuliaEnvironment HTTP server and provides
+    methods to interact with it: reset(), step(), and state access.
+    
+    Example:
+        >>> # Connect to a running server
+        >>> client = JuliaEnv(base_url="http://localhost:8000")
+        >>> result = client.reset()
+        >>> print(result.observation.stdout)
+        >>>
+        >>> # Execute Julia code
+        >>> action = JuliaAction(code='''
+        ... function multiply(a, b)
+        ...     return a * b
+        ... end
+        ... 
+        ... using Test
+        ... @test multiply(3, 4) == 12
+        ... ''')
+        >>> result = client.step(action)
+        >>> print(result.observation.tests_passed)  # 1
+        >>> print(result.reward)
+
+    Example with Docker:
+        >>> # Automatically start container and connect
+        >>> client = JuliaEnv.from_docker_image("julia-env:latest")
+        >>> result = client.reset()
+        >>> result = client.step(JuliaAction(code="println(2 + 2)"))
+        >>> print(result.observation.stdout)  # "4\n"
+        >>> client.close()
+    """
+
+    def _step_payload(self, action: JuliaAction) -> Dict:
+        """
+        Convert JuliaAction to JSON payload for step request.
+        
+        Args:
+            action: JuliaAction instance
+            
+        Returns:
+            Dictionary representation suitable for JSON encoding
+        """
+        return {
+            "core_code": action.core_code,
+            "test_code": action.test_code
+        }
+
+    def _parse_result(self, payload: Dict) -> StepResult[JuliaObservation]:
+        """
+        Parse server response into StepResult[JuliaObservation].
+        
+        Args:
+            payload: JSON response from server
+            
+        Returns:
+            StepResult with JuliaObservation
+        """
+        obs_data = payload.get("observation", {})
+        observation = JuliaObservation(
+            stdout=obs_data.get("stdout", ""),
+            stderr=obs_data.get("stderr", ""),
+            exit_code=obs_data.get("exit_code", 0),
+            tests_passed=obs_data.get("tests_passed", 0),
+            tests_failed=obs_data.get("tests_failed", 0),
+            code_compiles=obs_data.get("code_compiles", True),
+            metadata=obs_data.get("metadata", {}),
+        )
+        
+        return StepResult[JuliaObservation](
+            observation=observation,
+            reward=payload.get("reward"),
+            done=payload.get("done", False),
+        )
+
+    def _parse_state(self, payload: Dict) -> JuliaState:
+        """
+        Parse server response into JuliaState object.
+        
+        Args:
+            payload: JSON response from /state endpoint
+            
+        Returns:
+            JuliaState object with episode metadata
+        """
+        return JuliaState(
+            episode_id=payload.get("episode_id"),
+            step_count=payload.get("step_count", 0),
+            last_exit_code=payload.get("last_exit_code", 0),
+            last_code_compiles=payload.get("last_code_compiles", True),
+            total_tests_passed=payload.get("total_tests_passed", 0),
+            total_tests_failed=payload.get("total_tests_failed", 0),
+        )
+
diff --git a/src/envs/julia_env/models.py b/src/envs/julia_env/models.py
new file mode 100644
index 00000000..ced79d03
--- /dev/null
+++ b/src/envs/julia_env/models.py
@@ -0,0 +1,70 @@
+# Copyright (c) Yogesh Singla and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+Data models for the Julia Environment.
+
+The Julia environment executes Julia code and provides feedback through
+compilation and unit test results.
+"""
+
+from dataclasses import dataclass, field
+from typing import Optional
+
+from core.env_server.types import Action, Observation, State
+
+
+@dataclass(kw_only=True)
+class JuliaAction(Action):
+    """
+    Action for the Julia environment - code to execute.
+    
+    Attributes:
+        core_code: Core Julia code to execute
+        test_code: Test code to execute
+    """
+    core_code: str
+    test_code: str
+
+@dataclass(kw_only=True)
+class JuliaObservation(Observation):
+    """
+    Observation from the Julia environment - execution results.
+    
+    Attributes:
+        stdout: Standard output from Julia execution
+        stderr: Standard error from Julia execution
+        exit_code: Exit code (0 = success, non-zero = error)
+        execution_time: Time taken to execute in seconds
+        tests_passed: Number of tests passed (if tests were run)
+        tests_failed: Number of tests failed (if tests were run)
+        code_compiles: Whether the core code compiled/executed successfully
+    """
+    stdout: str = ""
+    stderr: str = ""
+    exit_code: int = 0
+    tests_passed: int = 0
+    tests_failed: int = 0
+    code_compiles: bool = True
+
+
+@dataclass
+class JuliaState(State):
+    """
+    State for Julia environment.
+    
+    Attributes:
+        episode_id: Unique episode identifier
+        step_count: Number of steps taken in episode
+        last_exit_code: Exit code from last execution
+        total_tests_passed: Cumulative tests passed in episode
+        total_tests_failed: Cumulative tests failed in episode
+    """
+    last_exit_code: int = 0
+    last_code_compiles: bool = True
+    total_tests_passed: int = 0
+    total_tests_failed: int = 0
+
diff --git a/src/envs/julia_env/server/Dockerfile b/src/envs/julia_env/server/Dockerfile
new file mode 100644
index 00000000..a8b0f3ae
--- /dev/null
+++ b/src/envs/julia_env/server/Dockerfile
@@ -0,0 +1,54 @@
+# Copyright (c) Yogesh Singla, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# Use the standard openenv base image
+# Built from: docker build -t openenv-base:latest -f src/core/containers/images/Dockerfile .
+# In GitHub Actions, this is overridden to use the GHCR base image
+
+# Use the standard openenv base image
+ARG BASE_IMAGE=openenv-base:latest
+FROM ${BASE_IMAGE}
+
+# Install Julia using juliaup (official installer - more reliable in Docker)
+RUN apt-get update && apt-get install -y \
+    curl \
+    ca-certificates \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install juliaup and Julia
+RUN curl -fsSL https://install.julialang.org | sh -s -- --yes --default-channel 1.10
+
+# Add Julia to PATH
+ENV PATH="/root/.juliaup/bin:${PATH}"
+
+# Verify Julia installation
+RUN julia --version
+
+# Precompile commonly used Julia packages (Test is built-in, but precompile it)
+RUN julia -e 'using Test; println("Julia Test module ready")'
+
+# Install smolagents for Python code execution utilities
+RUN pip install --no-cache-dir smolagents
+
+# Environment variable to enable Julia process pool (optional - can be set at runtime)
+# Set to "1" to enable process pool, "0" to use standard execution
+ENV JULIA_USE_PROCESS_POOL=1
+ENV JULIA_POOL_SIZE=32
+
+# Copy only what's needed for the Julia environment
+COPY src/core/ /app/src/core/
+COPY src/envs/julia_env/ /app/src/envs/julia_env/
+
+# Environment variables for port and workers with defaults
+ENV PORT=8000
+ENV NUM_WORKER=4
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=5s --start-period=30s --retries=3 \
+    CMD curl -f http://localhost:${PORT}/health || exit 1
+
+# Run the FastAPI server
+CMD uvicorn envs.julia_env.server.app:app --host 0.0.0.0 --port ${PORT} --workers ${NUM_WORKER}
diff --git a/src/envs/julia_env/server/README.md b/src/envs/julia_env/server/README.md
new file mode 100644
index 00000000..0d4882c8
--- /dev/null
+++ b/src/envs/julia_env/server/README.md
@@ -0,0 +1,436 @@
+# Julia Environment Server
+
+HTTP server for executing Julia code with test result tracking and reward calculation.
+
+## Overview
+
+This server provides a Julia code execution environment through OpenEnv's HTTP interface. It executes Julia code, parses test results from the `Test` module, and calculates rewards based on execution success and test outcomes.
+
+## Features
+
+- ✅ Execute Julia code in isolated subprocess
+- ✅ Parse `Test` module output (tests passed/failed)
+- ✅ Calculate rewards based on execution results
+- ✅ Safety transforms for output truncation
+- ✅ Docker support for reproducible execution
+- ✅ Compatible with GRPO training
+
+## Docker Setup
+
+### Prerequisites
+
+First, build the OpenEnv base image (one-time setup):
+
+```bash
+# From OpenEnv root directory
+docker build -t openenv-base:latest -f src/core/containers/images/Dockerfile .
+```
+
+### Build Julia Environment Image
+
+```bash
+# From OpenEnv root directory
+docker build -t julia-env:latest -f src/envs/julia_env/server/Dockerfile .
+```
+
+### Run the Server
+
+```bash
+# Run in background with default settings (port 8000, 4 workers)
+docker run -d -p 8000:8000 --name julia-env-server julia-env:latest
+
+# OR run in foreground (to see logs)
+docker run -p 8000:8000 --name julia-env-server julia-env:latest
+
+# Run with custom port
+docker run -d -p 9000:9000 -e PORT=9000 --name julia-env-server julia-env:latest
+
+# Run with custom number of workers (uvicorn workers)
+docker run -d -p 8000:8000 -e NUM_WORKER=8 --name julia-env-server julia-env:latest
+
+# Run with custom Julia max workers (for process pool)
+docker run -d -p 8000:8000 -e JULIA_MAX_WORKERS=32 --name julia-env-server julia-env:latest
+
+# Run with all custom configurations
+docker run -d -p 9000:9000 \
+  -e PORT=9000 \
+  -e NUM_WORKER=8 \
+  -e JULIA_MAX_WORKERS=32 \
+  --name julia-env-server julia-env:latest
+```
+
+### Test the Server
+
+```bash
+# Health check
+curl http://localhost:8000/health
+# Expected: {"status":"healthy"}
+
+# Check Julia version inside container
+docker exec julia-env-server julia --version
+# Expected: julia version 1.10.0
+```
+
+### Docker Management Commands
+
+```bash
+# View logs
+docker logs julia-env-server
+docker logs -f julia-env-server  # Follow logs
+
+# Stop/start container
+docker stop julia-env-server
+docker start julia-env-server
+
+# Remove container
+docker rm -f julia-env-server
+
+# Rebuild after code changes
+docker build -t julia-env:latest -f src/envs/julia_env/server/Dockerfile .
+docker rm -f julia-env-server
+docker run -d -p 8000:8000 --name julia-env-server julia-env:latest
+
+# Interactive debugging
+docker exec -it julia-env-server /bin/bash
+```
+
+## Local Development (Without Docker)
+
+### Prerequisites
+
+- Python 3.10+
+- Julia 1.10.0+ installed and in PATH
+- FastAPI and dependencies
+
+### Install Julia
+
+**Using juliaup (recommended):**
+```bash
+curl -fsSL https://install.julialang.org | sh
+```
+
+**Or download from:** https://julialang.org/downloads/
+
+### Install Python Dependencies
+
+```bash
+pip install fastapi uvicorn
+```
+
+### Run Server Locally
+
+```bash
+# From OpenEnv root directory
+export PYTHONPATH="${PWD}/src:${PYTHONPATH}"
+python -m envs.julia_env.server.app
+```
+
+Server will start at: http://localhost:8000
+
+## API Endpoints
+
+### Health Check
+```
+GET /health
+Response: {"status": "healthy"}
+```
+
+### Reset Environment
+```
+POST /reset
+Response: {
+  "observation": {
+    "stdout": "",
+    "stderr": "",
+    "exit_code": 0,
+    "tests_passed": 0,
+    "tests_failed": 0,
+    "reward": 0.0,
+    "execution_time": 0.0
+  }
+}
+```
+
+### Execute Code (Step)
+```
+POST /step
+Body: {"code": "function add(a,b)\n  a+b\nend\nusing Test\n@test add(2,3)==5"}
+Response: {
+  "observation": {
+    "stdout": "Test Passed",
+    "stderr": "",
+    "exit_code": 0,
+    "tests_passed": 1,
+    "tests_failed": 0,
+    "reward": 1.0,
+    "execution_time": 0.15
+  },
+  "reward": 1.0,
+  "done": false
+}
+```
+
+### Get State
+```
+GET /state
+Response: {
+  "episode_id": "uuid",
+  "step_count": 5,
+  "last_exit_code": 0,
+  "total_tests_passed": 10,
+  "total_tests_failed": 2
+}
+```
+
+## Reward Structure
+
+The environment calculates rewards based on:
+
+- **Failed execution** (exit_code != 0): `-0.5`
+- **Clean execution** (exit_code == 0): `+0.2`
+- **Tests passed**: `+0.3 × (passed/total)`
+- **Tests failed**: `-0.2 × (failed/total)`
+- **All tests passed bonus**: `+0.5`
+
+Example:
+```julia
+# 3 tests pass, 1 fails → exit_code 1
+reward = -0.5  # Failed execution
+# Total: -0.5
+
+# 3 tests pass, 0 fail → exit_code 0
+reward = 0.2 + 0.3 × 1.0 + 0.5 = 1.0
+# Total: 1.0 (perfect score!)
+```
+
+## Test Parsing
+
+The environment parses Julia's `Test` module output:
+
+### Method 1: Error Message Pattern
+```
+Some tests did not pass: 3 passed, 1 failed, 0 errored, 0 broken.
+→ tests_passed=3, tests_failed=1
+```
+
+### Method 2: Test Summary Table
+```
+Test Summary:      | Pass  Fail  Total  Time
+Add function Tests |    3     1      4  0.5s
+→ tests_passed=3, tests_failed=1
+```
+
+## Example Usage
+
+### From Python Client
+
+```python
+from envs.julia_env import JuliaEnv, JuliaAction
+
+# Connect to server
+env = JuliaEnv(base_url="http://localhost:8000")
+
+# Reset
+result = env.reset()
+
+# Execute Julia code with tests
+code = """
+function fibonacci(n)
+    if n <= 1
+        return n
+    end
+    return fibonacci(n-1) + fibonacci(n-2)
+end
+
+using Test
+@test fibonacci(0) == 0
+@test fibonacci(1) == 1
+@test fibonacci(5) == 5
+@test fibonacci(10) == 55
+"""
+
+result = env.step(JuliaAction(code=code))
+
+print(f"Exit code: {result.observation.exit_code}")
+print(f"Tests passed: {result.observation.tests_passed}")
+print(f"Tests failed: {result.observation.tests_failed}")
+print(f"Reward: {result.reward}")
+
+# Close connection
+env.close()
+```
+
+### Example Script
+
+```bash
+# From OpenEnv root
+python examples/julia_simple.py
+```
+
+## GRPO Training Integration
+
+This environment is designed for GRPO (Group Relative Policy Optimization) training:
+
+```python
+# In your GRPO training loop
+async def play_julia_game(game_idx, game_id, server_url, policy, tokenizer):
+    env = JuliaEnv(base_url=server_url)
+
+    # Generate code with LLM
+    prompt = format_julia_prompt(task)
+    responses = await policy.generate.route(prompt)
+    code = extract_julia_code(responses[0].text)
+
+    # Execute in environment
+    result = env.step(JuliaAction(code=code))
+
+    # Get reward
+    reward = result.observation.reward
+
+    return {
+        "prompt": prompt,
+        "response": responses[0],
+        "reward": reward,
+        "tests_passed": result.observation.tests_passed,
+        "tests_failed": result.observation.tests_failed
+    }
+```
+
+See `examples/grpo_blackjack/` for a complete GRPO training example that can be adapted for Julia.
+
+## Configuration
+
+### Docker Environment Variables
+
+The Docker container accepts the following environment variables:
+
+- **`PORT`**: HTTP server port (default: `8000`)
+  - Controls which port the FastAPI server listens on
+  - Must match the port mapping in `-p` flag (e.g., `-p 9000:9000 -e PORT=9000`)
+
+- **`NUM_WORKER`**: Number of uvicorn worker processes (default: `4`)
+  - Controls parallel request handling capacity
+  - More workers = more concurrent requests but higher memory usage
+  - Recommended: 2-8 workers for typical workloads
+
+- **`JULIA_MAX_WORKERS`**: Maximum Julia process pool size (default: `16`)
+  - Controls maximum concurrent Julia code executions
+  - Higher values allow more parallel Julia executions
+  - Each worker consumes memory; tune based on available resources
+  - Recommended: 8-32 workers depending on your workload
+
+### Runtime Environment Variables
+
+These can be set when running locally (non-Docker):
+
+- `HOST`: Server host (default: 0.0.0.0)
+- `JULIA_TIMEOUT`: Julia execution timeout in seconds (default: 60)
+
+### Dockerfile Customization
+
+To use a different Julia version:
+
+```dockerfile
+# In Dockerfile, change the version
+RUN curl -fsSL https://install.julialang.org | sh -s -- --yes --default-channel 1.11
+```
+
+## Troubleshooting
+
+### Julia not found
+```bash
+# Verify Julia is in PATH
+julia --version
+
+# In Docker, check installation
+docker exec julia-env-server julia --version
+```
+
+### Port already in use
+```bash
+# Use different port
+docker run -p 8001:8000 --name julia-env-server julia-env:latest
+
+# Update client base_url
+env = JuliaEnv(base_url="http://localhost:8001")
+```
+
+### Container exits immediately
+```bash
+# Check logs
+docker logs julia-env-server
+
+# Run in foreground to see errors
+docker run -p 8000:8000 julia-env:latest
+```
+
+### Build failures
+```bash
+# Clean build with no cache
+docker build --no-cache -t julia-env:latest -f src/envs/julia_env/server/Dockerfile .
+
+# Verbose output
+docker build --progress=plain -t julia-env:latest -f src/envs/julia_env/server/Dockerfile .
+```
+
+## Architecture
+
+```
+┌─────────────────────────────────────┐
+│   Python Client (HTTP)              │
+│   JuliaEnv                          │
+└────────────┬────────────────────────┘
+             │ HTTP POST /step
+             │ {"code": "..."}
+             ▼
+┌─────────────────────────────────────┐
+│   FastAPI Server                    │
+│   app.py                            │
+└────────────┬────────────────────────┘
+             │
+             ▼
+┌─────────────────────────────────────┐
+│   JuliaCodeActEnv                   │
+│   - Execute code via JuliaExecutor  │
+│   - Parse test results              │
+│   - Calculate rewards               │
+│   - Apply transforms                │
+└────────────┬────────────────────────┘
+             │
+             ▼
+┌─────────────────────────────────────┐
+│   JuliaExecutor (subprocess)        │
+│   - Write code to temp file         │
+│   - Run: julia temp_file.jl         │
+│   - Capture stdout/stderr           │
+│   - Return results                  │
+└─────────────────────────────────────┘
+```
+
+## Development
+
+### Running Tests
+
+```bash
+# Unit tests
+pytest tests/envs/julia_env/
+
+# Integration test
+python examples/julia_simple.py
+```
+
+### Code Structure
+
+```
+server/
+├── Dockerfile              # Docker build instructions
+├── README.md              # This file
+├── __init__.py            # Package initialization
+├── app.py                 # FastAPI server entry point
+├── julia_codeact_env.py   # Environment implementation
+└── julia_transforms.py    # Output transforms
+```
+
+## License
+
+BSD-style license. See LICENSE file in repository root.
diff --git a/src/envs/julia_env/server/__init__.py b/src/envs/julia_env/server/__init__.py
new file mode 100644
index 00000000..6f3f316c
--- /dev/null
+++ b/src/envs/julia_env/server/__init__.py
@@ -0,0 +1,8 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""Julia Environment Server."""
+
diff --git a/src/envs/julia_env/server/app.py b/src/envs/julia_env/server/app.py
new file mode 100644
index 00000000..c2a35843
--- /dev/null
+++ b/src/envs/julia_env/server/app.py
@@ -0,0 +1,455 @@
+# Copyright (c) Yogesh Singla and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+FastAPI application for the Julia Environment with concurrent execution support.
+
+This module creates an HTTP server that exposes the JuliaCodeActEnv
+over HTTP endpoints with optimized async execution for handling multiple
+concurrent requests efficiently.
+
+Features:
+- Async Julia code execution to avoid blocking
+- Environment pool for concurrent request handling
+- Thread pool executor for CPU-bound Julia tasks
+- Automatic error recovery and retry logic
+- Comprehensive logging to file and console
+- Worker health monitoring and auto-restart
+- 10x+ performance improvement over single-threaded version
+
+Usage:
+    # Development (with auto-reload):
+    uvicorn envs.julia_env.server.app:app --reload --host 0.0.0.0 --port 8000
+
+    # Production (with multiple workers for even better concurrency):
+    uvicorn envs.julia_env.server.app:app --host 0.0.0.0 --port 8000 --workers 4
+
+    # Or run directly:
+    python -m envs.julia_env.server.app
+"""
+
+import asyncio
+import logging
+import os
+import sys
+import traceback
+from concurrent.futures import ThreadPoolExecutor
+from contextlib import asynccontextmanager
+from dataclasses import asdict
+from datetime import datetime
+from logging.handlers import RotatingFileHandler
+from typing import Any, Dict
+
+from fastapi import Body, FastAPI, HTTPException, Request
+from fastapi.responses import JSONResponse
+
+from ..models import JuliaAction, JuliaObservation
+from .julia_codeact_env import JuliaCodeActEnv
+
+# Configuration
+MAX_WORKERS = int(
+    os.getenv("JULIA_MAX_WORKERS", "8")
+)  # Number of concurrent Julia executions
+ENABLE_WEB = os.getenv("ENABLE_WEB_INTERFACE", "false").lower() in ("true", "1", "yes")
+EXECUTION_TIMEOUT = int(os.getenv("JULIA_EXECUTION_TIMEOUT", "120"))  # seconds
+LOG_FILE = os.getenv("JULIA_LOG_FILE", "/tmp/run.log")
+LOG_LEVEL = os.getenv("JULIA_LOG_LEVEL", "INFO")
+
+# Global thread pool executor for CPU-bound Julia tasks
+executor = None
+
+
+# Setup comprehensive logging
+def setup_logging():
+    """Configure logging to both file and console with rotation."""
+    logger = logging.getLogger("julia_env")
+    logger.setLevel(getattr(logging, LOG_LEVEL))
+
+    # Prevent duplicate handlers
+    if logger.handlers:
+        return logger
+
+    # Create formatters
+    detailed_formatter = logging.Formatter(
+        "%(asctime)s - %(name)s - [%(process)d:%(thread)d] - %(levelname)s - %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    )
+
+    # File handler with rotation (10MB max, keep 5 backup files)
+    try:
+        os.makedirs(os.path.dirname(LOG_FILE), exist_ok=True)
+        file_handler = RotatingFileHandler(
+            LOG_FILE, maxBytes=10 * 1024 * 1024, backupCount=5, encoding="utf-8"  # 10MB
+        )
+        file_handler.setLevel(logging.DEBUG)
+        file_handler.setFormatter(detailed_formatter)
+        logger.addHandler(file_handler)
+    except Exception as e:
+        print(f"Warning: Could not create log file {LOG_FILE}: {e}")
+
+    # Console handler
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setLevel(logging.INFO)
+    console_handler.setFormatter(detailed_formatter)
+    logger.addHandler(console_handler)
+
+    return logger
+
+
+logger = setup_logging()
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Lifespan context manager for startup/shutdown with health monitoring"""
+    global executor
+
+    logger.info("=" * 80)
+    logger.info("Starting Julia Environment Server")
+    logger.info(f"Max Workers: {MAX_WORKERS}")
+    logger.info(f"Execution Timeout: {EXECUTION_TIMEOUT}s")
+    logger.info(f"Log File: {LOG_FILE}")
+    logger.info(f"Log Level: {LOG_LEVEL}")
+    logger.info("=" * 80)
+
+    # Startup: Create thread pool with error handling
+    try:
+        executor = ThreadPoolExecutor(
+            max_workers=MAX_WORKERS, thread_name_prefix="julia_worker"
+        )
+        logger.info(f"✅ Thread pool created with {MAX_WORKERS} workers")
+        logger.info(f"✅ Julia Environment Server started successfully")
+        print(
+            f"✅ Julia Environment Server started with {MAX_WORKERS} concurrent workers"
+        )
+    except Exception as e:
+        logger.error(f"❌ Failed to start server: {e}")
+        logger.error(traceback.format_exc())
+        raise
+
+    yield
+
+    # Shutdown: Cleanup with grace period
+    logger.info("Shutting down Julia Environment Server...")
+    try:
+        executor.shutdown(wait=True, cancel_futures=False)
+        logger.info("✅ All workers completed gracefully")
+    except Exception as e:
+        logger.error(f"Error during shutdown: {e}")
+
+    logger.info("✅ Julia Environment Server shutdown complete")
+    print("✅ Julia Environment Server shutdown complete")
+
+
+# Create FastAPI app with lifespan management
+app = FastAPI(
+    title="Julia Environment Server",
+    description="Async Julia code execution environment with concurrent request support and auto-recovery",
+    version="2.1.0",
+    lifespan=lifespan,
+)
+
+
+# Global exception handler for uncaught errors
+@app.exception_handler(Exception)
+async def global_exception_handler(request: Request, exc: Exception):
+    """Handle all uncaught exceptions to prevent worker crashes"""
+    error_id = datetime.now().strftime("%Y%m%d_%H%M%S_%f")
+    logger.error(f"[ERROR-{error_id}] Uncaught exception in {request.url.path}")
+    logger.error(f"[ERROR-{error_id}] Request: {request.method} {request.url}")
+    logger.error(f"[ERROR-{error_id}] Exception: {type(exc).__name__}: {exc}")
+    logger.error(f"[ERROR-{error_id}] Traceback:\n{traceback.format_exc()}")
+
+    return JSONResponse(
+        status_code=500,
+        content={
+            "error": "Internal server error",
+            "type": type(exc).__name__,
+            "message": str(exc),
+            "error_id": error_id,
+            "timestamp": datetime.now().isoformat(),
+        },
+    )
+
+
+async def execute_julia_async(
+    action: JuliaAction, request_id: str = None
+) -> JuliaObservation:
+    """
+    Execute Julia code asynchronously in thread pool with timeout and error recovery.
+
+    This runs the CPU-bound Julia execution in a separate thread to avoid
+    blocking the event loop, allowing the server to handle multiple requests
+    concurrently.
+
+    Features:
+    - Timeout protection
+    - Automatic retry on transient failures
+    - Comprehensive error logging
+    - Resource cleanup
+    """
+    if request_id is None:
+        request_id = datetime.now().strftime("%Y%m%d_%H%M%S_%f")
+
+    loop = asyncio.get_event_loop()
+    max_retries = 2
+    retry_count = 0
+
+    logger.debug(
+        f"[{request_id}] Starting Julia execution (timeout: {EXECUTION_TIMEOUT}s)"
+    )
+
+    while retry_count <= max_retries:
+        env = None
+        try:
+            # Create a fresh environment instance for this request
+            # This ensures thread safety and allows concurrent execution
+            env = JuliaCodeActEnv()
+
+            # Run the blocking step() call in thread pool with timeout
+            observation = await asyncio.wait_for(
+                loop.run_in_executor(executor, env.step, action),
+                timeout=EXECUTION_TIMEOUT,
+            )
+
+            logger.debug(f"[{request_id}] Julia execution completed successfully")
+            logger.debug(
+                f"[{request_id}] Result: tests_passed={observation.tests_passed}, "
+                f"tests_failed={observation.tests_failed}, reward={observation.reward}"
+            )
+
+            return observation
+
+        except asyncio.TimeoutError:
+            retry_count += 1
+            logger.warning(
+                f"[{request_id}] Julia execution timeout (attempt {retry_count}/{max_retries + 1})"
+            )
+
+            if retry_count > max_retries:
+                logger.error(
+                    f"[{request_id}] Julia execution failed after {max_retries + 1} attempts"
+                )
+                # Return a failure observation
+                return JuliaObservation(
+                    stdout="",
+                    stderr=f"Execution timeout after {EXECUTION_TIMEOUT}s",
+                    exit_code=-1,
+                    tests_passed=0,
+                    tests_failed=1,
+                    code_compiles=False,
+                    reward=0.0,
+                    done=True,
+                )
+
+            # Wait a bit before retry
+            await asyncio.sleep(0.5)
+
+        except Exception as e:
+            retry_count += 1
+            logger.error(
+                f"[{request_id}] Julia execution error (attempt {retry_count}/{max_retries + 1}): {e}"
+            )
+            logger.error(f"[{request_id}] Traceback:\n{traceback.format_exc()}")
+
+            if retry_count > max_retries:
+                logger.error(
+                    f"[{request_id}] Julia execution failed permanently after {max_retries + 1} attempts"
+                )
+                # Return a failure observation
+                return JuliaObservation(
+                    stdout="",
+                    stderr=f"Execution error: {str(e)}",
+                    exit_code=-1,
+                    tests_passed=0,
+                    tests_failed=1,
+                    code_compiles=False,
+                    reward=0.0,
+                    done=True,
+                )
+
+            # Wait a bit before retry
+            await asyncio.sleep(0.5)
+
+        finally:
+            # Clean up environment resources if possible
+            if env is not None:
+                try:
+                    # Add any cleanup needed here
+                    del env
+                except Exception as cleanup_error:
+                    logger.debug(f"[{request_id}] Cleanup warning: {cleanup_error}")
+
+
+@app.post("/reset")
+async def reset(request: Dict[str, Any] = Body(default={})) -> Dict[str, Any]:
+    """
+    Reset endpoint - returns initial observation.
+
+    Creates a fresh environment instance for the new episode.
+    """
+    request_id = datetime.now().strftime("%Y%m%d_%H%M%S_%f")
+    logger.info(f"[{request_id}] Reset request received")
+
+    try:
+        # Run reset in thread pool to avoid blocking
+        loop = asyncio.get_event_loop()
+        env = JuliaCodeActEnv()
+        observation = await asyncio.wait_for(
+            loop.run_in_executor(executor, env.reset),
+            timeout=30.0,  # Reset should be quick
+        )
+
+        # Serialize observation
+        obs_dict = asdict(observation)
+        reward = obs_dict.pop("reward", None)
+        done = obs_dict.pop("done", False)
+        obs_dict.pop("metadata", None)
+
+        logger.info(f"[{request_id}] Reset completed successfully")
+
+        return {
+            "observation": obs_dict,
+            "reward": reward,
+            "done": done,
+        }
+    except asyncio.TimeoutError:
+        logger.error(f"[{request_id}] Reset timeout")
+        raise HTTPException(status_code=504, detail="Reset operation timed out")
+    except Exception as e:
+        logger.error(f"[{request_id}] Reset error: {e}")
+        logger.error(traceback.format_exc())
+        raise HTTPException(status_code=500, detail=f"Reset failed: {str(e)}")
+
+
+@app.post("/step")
+async def step(request: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Step endpoint - executes Julia code and returns observation.
+
+    Runs Julia code execution asynchronously to handle multiple concurrent requests.
+    Each request gets its own environment instance for thread safety.
+    """
+    request_id = datetime.now().strftime("%Y%m%d_%H%M%S_%f")
+
+    try:
+        action_data = request.get("action", {})
+        if not action_data:
+            logger.warning(f"[{request_id}] Step request with empty action")
+            raise HTTPException(status_code=400, detail="Action data is required")
+
+        # Deserialize action
+        metadata = action_data.pop("metadata", {})
+        action = JuliaAction(**action_data)
+        action.metadata = metadata
+
+        logger.info(f"[{request_id}] Step request received")
+        logger.debug(
+            f"[{request_id}] Action: core_code_length={len(action.core_code) if action.core_code else 0}, "
+            f"test_code_length={len(action.test_code) if action.test_code else 0}"
+        )
+
+        # Execute Julia code asynchronously with timeout and retry
+        observation = await execute_julia_async(action, request_id)
+
+        # Serialize observation
+        obs_dict = asdict(observation)
+        reward = obs_dict.pop("reward", None)
+        done = obs_dict.pop("done", False)
+        obs_dict.pop("metadata", None)
+
+        logger.info(
+            f"[{request_id}] Step completed - reward={reward}, "
+            f"tests_passed={observation.tests_passed}, tests_failed={observation.tests_failed}"
+        )
+
+        return {
+            "observation": obs_dict,
+            "reward": reward,
+            "done": done,
+        }
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"[{request_id}] Step endpoint error: {e}")
+        logger.error(f"[{request_id}] Traceback:\n{traceback.format_exc()}")
+        raise HTTPException(status_code=500, detail=f"Step execution failed: {str(e)}")
+
+
+@app.get("/state")
+async def get_state() -> Dict[str, Any]:
+    """
+    State endpoint - returns environment metadata and server health.
+
+    Note: Since each request creates a fresh environment, this returns
+    general server state rather than specific episode state.
+    """
+    try:
+        import psutil
+
+        process = psutil.Process()
+        memory_info = process.memory_info()
+
+        return {
+            "max_workers": MAX_WORKERS,
+            "executor_type": "ThreadPoolExecutor",
+            "status": "ready",
+            "timeout": EXECUTION_TIMEOUT,
+            "log_file": LOG_FILE,
+            "memory_mb": memory_info.rss / 1024 / 1024,
+            "threads": len(process.threads()),
+        }
+    except ImportError:
+        # psutil not available, return basic info
+        return {
+            "max_workers": MAX_WORKERS,
+            "executor_type": "ThreadPoolExecutor",
+            "status": "ready",
+            "timeout": EXECUTION_TIMEOUT,
+            "log_file": LOG_FILE,
+        }
+    except Exception as e:
+        logger.warning(f"Could not get full state info: {e}")
+        return {
+            "max_workers": MAX_WORKERS,
+            "executor_type": "ThreadPoolExecutor",
+            "status": "ready",
+        }
+
+
+@app.get("/health")
+async def health() -> Dict[str, str]:
+    """
+    Health check endpoint.
+
+    Returns healthy status if the server is operational and can accept requests.
+    """
+    try:
+        # Quick health check - verify executor is available
+        if executor is None:
+            logger.error("Health check failed: executor not initialized")
+            raise HTTPException(status_code=503, detail="Service not ready")
+
+        return {
+            "status": "healthy",
+            "workers": str(MAX_WORKERS),
+            "timeout": str(EXECUTION_TIMEOUT),
+            "timestamp": datetime.now().isoformat(),
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Health check error: {e}")
+        raise HTTPException(status_code=503, detail="Health check failed")
+
+
+if __name__ == "__main__":
+    import uvicorn
+
+    # Run with uvicorn
+    # Use multiple workers for even better concurrency
+    uvicorn.run(app, host="0.0.0.0", port=8000, log_level="info")
diff --git a/src/envs/julia_env/server/julia_codeact_env.py b/src/envs/julia_env/server/julia_codeact_env.py
new file mode 100644
index 00000000..636201f8
--- /dev/null
+++ b/src/envs/julia_env/server/julia_codeact_env.py
@@ -0,0 +1,276 @@
+"""
+Julia Code Action Environment.
+
+This environment mirrors the PythonCodeActEnv but runs Julia code instead.
+It executes Julia code using JuliaExecutor, captures output,
+tracks the last exit code, and returns a JuliaObservation.
+"""
+
+import re
+import uuid
+
+from core.env_server import Environment
+from core.tools import JuliaExecutor
+from ..models import JuliaAction, JuliaObservation, JuliaState
+from .julia_transforms import create_safe_julia_transform
+
+
+class JuliaCodeActEnv(Environment):
+    """
+    Julia Code Action Environment for executing code and tracking state.
+
+    This environment executes Julia code submitted as CodeAction during step,
+    maintains the last exit code in its state, and returns results wrapped
+    in CodeObservation.
+
+    Example:
+        >>> env = JuliaCodeActEnv()
+        >>> obs = env.reset()
+        >>> action = CodeAction(code='println("Hello, Julia!")')
+        >>> obs = env.step(action)
+        >>> print(obs.stdout)  # "Hello, Julia!\n"
+        >>> print(obs.exit_code)  # 0
+        >>> print(env.state.last_exit_code)  # 0
+    """
+
+    def __init__(self):
+        """Initialize the Julia Code Act Environment."""
+        self._executor = JuliaExecutor()
+        self._state = JuliaState()
+        self.transform = create_safe_julia_transform()
+
+    def reset(self) -> JuliaObservation:
+        """
+        Reset environment for a fresh Julia execution session.
+        Returns an empty JuliaObservation with exit_code=0.
+        """
+        self._state = JuliaState(episode_id=str(uuid.uuid4()), step_count=0)
+        self._state.last_exit_code = 0
+        self._state.last_code_compiles = True
+        self._executor = JuliaExecutor()
+
+        observation = JuliaObservation(
+            stdout="",
+            stderr="",
+            exit_code=0,
+            reward=0.0,
+            metadata={"core_code": "", "test_code": ""},
+            tests_passed=0,
+            tests_failed=0,
+            code_compiles=True,
+        )
+
+        observation = self._apply_transform(observation)
+        return observation
+
+    def step(self, action: JuliaAction) -> JuliaObservation:
+        """
+        Execute Julia code and return the result as JuliaObservation.
+
+        Optimized single-pass execution:
+        - Runs core_code + test_code together
+        - Infers compilation status from combined execution
+        - 2x faster than double execution
+        """
+        if not isinstance(action, JuliaAction):
+            raise ValueError(f"Expected JuliaAction, got {type(action)}")
+
+        # Single execution: Run core_code + test_code together
+        combined_code = action.core_code + "\n\n" + action.test_code
+        full_result = self._executor.run(combined_code)
+
+        # Parse test results from execution output
+        tests_passed, tests_failed = self._parse_test_results(
+            full_result.stdout, full_result.stderr
+        )
+
+        # Infer compilation status from execution
+        # If tests ran, code compiled successfully
+        # If exit_code != 0 and no tests ran, code didn't compile
+        code_compiles = (
+            full_result.exit_code == 0  # Clean execution
+            or tests_passed > 0  # Some tests passed (code must have compiled)
+            or tests_failed > 0  # Some tests failed (code compiled but tests failed)
+        )
+
+        # If no tests detected and non-zero exit, check for compilation errors
+        if not code_compiles and tests_passed == 0 and tests_failed == 0:
+            # Check stderr for compilation errors
+            stderr_lower = full_result.stderr.lower()
+            if any(
+                err in stderr_lower
+                for err in ["error", "syntax", "undefined", "loadError"]
+            ):
+                code_compiles = False
+            else:
+                # If no clear compilation error, assume it compiled
+                code_compiles = True
+
+        # Calculate reward based on compilation and test results
+        reward = self._calculate_reward(code_compiles, tests_passed, tests_failed)
+
+        # Update environment state
+        self._state.step_count += 1
+        self._state.last_exit_code = full_result.exit_code
+        self._state.last_code_compiles = code_compiles
+        self._state.total_tests_passed = tests_passed
+        self._state.total_tests_failed = tests_failed
+
+        # Build observation
+        observation = JuliaObservation(
+            stdout=full_result.stdout,
+            stderr=full_result.stderr,
+            exit_code=full_result.exit_code,
+            reward=reward,
+            metadata={"core_code": action.core_code, "test_code": action.test_code},
+            tests_passed=tests_passed,
+            tests_failed=tests_failed,
+            code_compiles=code_compiles,
+        )
+
+        # Apply safety and quality transforms
+        observation = self._apply_transform(observation)
+
+        return observation
+
+    def _parse_test_results(self, stdout: str, stderr: str) -> tuple[int, int]:
+        """
+        Parse Julia test output to count passed/failed tests.
+
+        Julia's Test module outputs results like:
+        "Test Summary:      | Pass  Fail  Total  Time"
+        "Add function Tests |    1     1      2  1.5s"
+
+        Also checks error messages:
+        "Some tests did not pass: 1 passed, 1 failed, 0 errored, 0 broken."
+
+        Args:
+            stdout: Standard output from Julia execution
+            stderr: Standard error from Julia execution
+
+        Returns:
+            Tuple of (tests_passed, tests_failed)
+        """
+        # Combine stdout and stderr for analysis
+        passed = 0
+        failed = 0
+        output = stdout + "\n" + stderr
+
+        # Method 1: Look for "Some tests did not pass" error message
+        # Pattern: "Some tests did not pass: X passed, Y failed, Z errored, W broken."
+        error_pattern = r"Some tests did not pass:\s*(\d+)\s+passed,\s*(\d+)\s+failed,\s*(\d+)\s+errored"
+        match = re.search(error_pattern, output)
+
+        if match:
+            passed = int(match.group(1))
+            failed = int(match.group(2))
+            errored = int(match.group(3))
+            return passed, failed + errored  # Treat errors as failures
+
+        # Method 2: Look for Test Summary table
+        # Multiple possible formats:
+        # All pass:     "Test Summary: | Pass  Total  Time"
+        #               "My Tests     |    3      3  0.5s"
+        # Some fail:    "Test Summary: | Pass  Fail  Total  Time"
+        #               "My Tests     |    2     1      3  0.5s"
+        # All error:    "Test Summary: | Error  Total  Time"
+        #               "My Tests     |     3      3  0.9s"
+        # Mixed:        "Test Summary: | Pass  Fail  Error  Total  Time"
+        #               "My Tests     |    1     1      1      3  0.5s"
+        summary_lines = output.split("\n")
+        for i, line in enumerate(summary_lines):
+            if "Test Summary:" in line and i + 1 < len(summary_lines):
+                header_line = line
+                next_line = summary_lines[i + 1]
+
+                # Determine which columns are present
+                has_pass = "Pass" in header_line
+                has_fail = "Fail" in header_line
+                has_error = "Error" in header_line
+
+                # Extract all numbers from the line
+                all_numbers = re.findall(r"\d+", next_line)
+                if not all_numbers:
+                    continue
+
+                # Last number is always Total, second to last is Time (skip it)
+                # Extract based on which columns exist
+                if has_pass and has_fail and has_error:
+                    # Pass  Fail  Error  Total  Time
+                    if len(all_numbers) >= 5:
+                        passed = int(all_numbers[0])
+                        failed = int(all_numbers[1]) + int(
+                            all_numbers[2]
+                        )  # Fail + Error
+                        return passed, failed
+                elif has_pass and has_fail:
+                    # Pass  Fail  Total  Time
+                    if len(all_numbers) >= 4:
+                        passed = int(all_numbers[0])
+                        failed = int(all_numbers[1])
+                        return passed, failed
+                elif has_pass and has_error:
+                    # Pass  Error  Total  Time
+                    if len(all_numbers) >= 4:
+                        passed = int(all_numbers[0])
+                        failed = int(all_numbers[1])  # Treat errors as failures
+                        return passed, failed
+                elif has_fail and has_error:
+                    # Fail  Error  Total  Time (no passes)
+                    if len(all_numbers) >= 4:
+                        passed = 0
+                        failed = int(all_numbers[0]) + int(all_numbers[1])
+                        return passed, failed
+                elif has_pass:
+                    # Pass  Total  Time (no failures/errors)
+                    if len(all_numbers) >= 3:
+                        passed = int(all_numbers[0])
+                        failed = 0
+                        return passed, failed
+                elif has_error:
+                    # Error  Total  Time (all errors, no passes)
+                    if len(all_numbers) >= 3:
+                        passed = 0
+                        failed = int(all_numbers[0])  # Treat all errors as failures
+                        return passed, failed
+                elif has_fail:
+                    # Fail  Total  Time (all failures, no passes)
+                    if len(all_numbers) >= 3:
+                        passed = 0
+                        failed = int(all_numbers[0])
+                        return passed, failed
+
+        return passed, failed
+
+    def _calculate_reward(
+        self, code_compiles: bool, tests_passed: int, tests_failed: int
+    ) -> int:
+        """
+        Optimized integer reward for Julia GRPO.
+        Strong signal shaping: rewards correctness, penalizes instability,
+        and gives higher incentive for near-perfect results.
+        """
+
+        # Code doesn't compile — immediate strong penalty
+        if not code_compiles:
+            return -3
+
+        reward = 1
+
+        reward += 3 * tests_passed - 1 * tests_failed
+
+        if tests_failed == 0 and tests_passed > 0:
+            reward += 2
+
+        return reward
+
+    def _apply_transform(self, observation: JuliaObservation) -> JuliaObservation:
+        """Apply safety and quality transforms to observation."""
+        if self.transform:
+            observation = self.transform(observation)
+        return observation
+
+    @property
+    def state(self) -> JuliaState:
+        """Return current environment state."""
+        return self._state
diff --git a/src/envs/julia_env/server/julia_transforms.py b/src/envs/julia_env/server/julia_transforms.py
new file mode 100644
index 00000000..f6e9ed4a
--- /dev/null
+++ b/src/envs/julia_env/server/julia_transforms.py
@@ -0,0 +1,87 @@
+"""
+envs/julia_env/julia_transforms.py
+--------------------------------
+Safety and quality transforms for Julia code.
+"""
+
+import re
+from core.env_server.base_transforms import CompositeTransform
+from core.env_server.interfaces import Transform
+from ..models import JuliaObservation
+
+
+# -------------------------
+# Safety Transform
+# -------------------------
+class JuliaSafetyTransform(Transform):
+    """Detects dangerous Julia operations and penalizes them with a negative reward."""
+
+    def __init__(self, penalty: float = -3.0):
+        self.penalty = penalty
+        self.dangerous_patterns = [
+            r"run\(",
+            r"read\(",
+            r"write\(",
+            r"unsafe_",
+            r"ccall\(",
+            r"Base\.exit",
+            r"Base\.kill",
+            r"rm\(",      # file deletion
+            r"download\(" # downloading
+        ]
+
+    def __call__(self, observation):
+        # Only act on JuliaObservation objects
+        if not isinstance(observation, JuliaObservation):
+            return observation
+
+        # Extract last executed code from metadata
+        code = observation.metadata.get("last_code", "") if observation.metadata else ""
+
+        for pattern in self.dangerous_patterns:
+            if re.search(pattern, code):
+                # Apply penalty and record violation
+                observation.reward = (observation.reward or 0.0) + self.penalty
+                observation.metadata = observation.metadata or {}
+                observation.metadata["safety_violation"] = pattern
+                return observation
+
+        # Safe code gets neutral reward
+        observation.reward = observation.reward or 0.0
+        return observation
+
+
+# -------------------------
+# Quality Transform
+# -------------------------
+class JuliaQualityTransform(Transform):
+    """Evaluates and rewards Julia code quality."""
+
+    def __init__(self, concise_bonus=1, max_length_threshold=120):
+        self.concise_bonus = concise_bonus
+        self.max_length_threshold = max_length_threshold
+
+    def __call__(self, observation):
+        # Only act on JuliaObservation objects
+        if not isinstance(observation, JuliaObservation):
+            return observation
+
+        code = observation.metadata.get("last_code", "") if observation.metadata else ""
+        reward = observation.reward or 0.0
+
+        # Reward concise code
+        if len(code.strip()) <= self.max_length_threshold:
+            reward += self.concise_bonus
+        else:
+            reward -= 0.1  # slight penalty for verbosity
+
+        observation.reward = reward
+        return observation
+
+
+# -------------------------
+# Composite Transform
+# -------------------------
+def create_safe_julia_transform():
+    """Combines safety and quality transforms into one pipeline."""
+    return CompositeTransform([JuliaSafetyTransform(), JuliaQualityTransform()])