torchmonarch-nightly 2025.7.25__cp310-cp310-manylinux2014_x86_64.whl → 2025.7.27__cp310-cp310-manylinux2014_x86_64.whl

monarch/mesh_controller.py

@@ -30,6 +30,7 @@ from monarch._rust_bindings.monarch_extension.client import (  # @manual=//monar
     WorldState,
 )
 from monarch._rust_bindings.monarch_extension.mesh_controller import _Controller
+from monarch._rust_bindings.monarch_extension.tensor_worker import Ref
 from monarch._rust_bindings.monarch_hyperactor.actor import (
     PythonMessage,
     PythonMessageKind,
@@ -44,10 +45,12 @@ from monarch._src.actor.endpoint import Selection
 from monarch._src.actor.shape import NDSlice
 from monarch.common import device_mesh, messages, stream
 from monarch.common.controller_api import TController
+from monarch.common.function import ResolvableFunction
 from monarch.common.invocation import Seq
 from monarch.common.messages import Referenceable, SendResultOfActorCall
 from monarch.common.stream import StreamRef
-from monarch.common.tensor import InputChecker, Tensor
+from monarch.common.tensor import dtensor_check, InputChecker, Tensor
+from monarch.common.tree import flatten
 from monarch.tensor_worker_main import _set_trace
 
 if TYPE_CHECKING:
@@ -265,17 +268,36 @@ class RemoteException(Exception):
             return "<exception formatting RemoteException>"
 
 
-def actor_send(
+def _cast_call_method_indirect(
     endpoint: ActorEndpoint,
+    selection: Selection,
+    client: MeshClient,
+    seq: Seq,
     args_kwargs_tuple: bytes,
     refs: Sequence[Any],
-    port: Optional[Port[Any]],
-    selection: Selection,
-):
+) -> Tuple[str, int]:
     unflatten_args = [
         UnflattenArg.PyObject if isinstance(ref, Tensor) else UnflattenArg.Mailbox
         for ref in refs
     ]
+    broker_id: Tuple[str, int] = client._mesh_controller.broker_id
+    actor_msg = PythonMessage(
+        PythonMessageKind.CallMethodIndirect(
+            endpoint._name, broker_id, seq, unflatten_args
+        ),
+        args_kwargs_tuple,
+    )
+    endpoint._actor_mesh.cast(actor_msg, selection)
+    return broker_id
+
+
+def actor_send(
+    endpoint: ActorEndpoint,
+    args_kwargs_tuple: bytes,
+    refs: Sequence[Any],
+    port: Optional[Port[Any]],
+    selection: Selection,
+):
     tensors = [ref for ref in refs if isinstance(ref, Tensor)]
     # we have some monarch references, we need to ensure their
     # proc_mesh matches that of the tensors we sent to it
@@ -284,7 +306,7 @@ def actor_send(
         if hasattr(t, "stream"):
             chosen_stream = t.stream
             break
-    with InputChecker(refs, lambda x: f"actor_call({x})") as checker:
+    with InputChecker(tensors, lambda x: f"actor_call({x})") as checker:
         checker.check_mesh_stream_local(device_mesh._active, chosen_stream)
         # TODO: move propagators into Endpoint abstraction and run the propagator to get the
         # mutates
@@ -300,8 +322,6 @@ def actor_send(
 
     client = cast(MeshClient, checker.mesh.client)
 
-    broker_id: Tuple[str, int] = client._mesh_controller.broker_id
-
     stream_ref = chosen_stream._to_ref(client)
 
     fut = (port, checker.mesh._ndslice) if port is not None else None
@@ -316,13 +336,9 @@ def actor_send(
     # The message to the generic actor tells it to first wait on the broker to get the local arguments
     # from the stream, then it will run the actor method, and send the result to response port.
 
-    actor_msg = PythonMessage(
-        PythonMessageKind.CallMethodIndirect(
-            endpoint._name, broker_id, ident, unflatten_args
-        ),
-        args_kwargs_tuple,
+    broker_id = _cast_call_method_indirect(
+        endpoint, selection, client, ident, args_kwargs_tuple, refs
     )
-    endpoint._actor_mesh.cast(actor_msg, selection)
     worker_msg = SendResultOfActorCall(ident, broker_id, tensors, [], stream_ref)
     client.send(checker.mesh._ndslice, worker_msg)
     # we have to ask for status updates
@@ -330,3 +346,49 @@ def actor_send(
     # enough work to count this future as finished,
     # and all potential errors have been reported
     client._request_status()
+
+
+def actor_rref(endpoint, args_kwargs_tuple: bytes, refs: Sequence[Any]):
+    chosen_stream = stream._active
+    fake_result, dtensors, mutates, mesh = dtensor_check(
+        endpoint._propagate,
+        cast(ResolvableFunction, endpoint._name),
+        refs,
+        {},
+        device_mesh._active,
+        chosen_stream,
+    )
+    assert mesh is not None
+
+    fake_result_dtensors, unflatten_result = flatten(
+        fake_result, lambda x: isinstance(x, torch.Tensor)
+    )
+    result_dtensors = tuple(
+        Tensor(fake, mesh, chosen_stream) for fake in fake_result_dtensors
+    )
+    seq = mesh.client.new_node(result_dtensors + mutates, dtensors)
+    assert all(t.ref is not None for t in result_dtensors)
+    assert all(t.ref is not None for t in mutates)
+    result = result_msg = unflatten_result(result_dtensors)
+    if len(result_dtensors) == 0:
+        result_msg = None
+
+    broker_id = _cast_call_method_indirect(
+        endpoint, "all", mesh.client, seq, args_kwargs_tuple, refs
+    )
+    # note the device mesh has to be defined regardles so the remote functions
+    # can invoke mesh.rank("...")
+
+    mesh.define_remotely()
+
+    mesh._send(
+        messages.CallActorMethod(
+            seq,
+            result_msg,
+            broker_id,
+            refs,
+            cast("List[Ref]", mutates),
+            stream._active._to_ref(mesh.client),
+        )
+    )
+    return result

monarch/tools/cli.py

@@ -86,9 +86,9 @@ class CreateCmd:
             else defaults.component_fn(config.scheduler)
         )
         component_args = component_args_from_cli(component_fn, args.component_args)
-        appdef = component_fn(**component_args)
+        config.appdef = component_fn(**component_args)
 
-        handle = create(config, appdef)
+        handle = create(config)
         print(handle)
 
 

monarch/tools/commands.py

@@ -7,18 +7,19 @@
 # pyre-strict
 
 import argparse
+import asyncio
 import inspect
 import logging
 import os
-import time
-from datetime import timedelta
+from datetime import datetime, timedelta
 from typing import Any, Callable, Mapping, Optional, Union
 
+from monarch.tools.components.hyperactor import DEFAULT_NAME
+
 from monarch.tools.config import (  # @manual=//monarch/python/monarch/tools/config/meta:defaults
     Config,
     defaults,
 )
-
 from monarch.tools.mesh_spec import mesh_spec_from_metadata, ServerSpec
 from torchx.runner import Runner  # @manual=//torchx/runner:lib_core
 from torchx.specs import AppDef, AppDryRunInfo, AppState, CfgVal, parse_app_handle
@@ -83,7 +84,7 @@ def component_args_from_cli(
 
 def create(
     config: Config,
-    appdef: AppDef,
+    name: str = DEFAULT_NAME,
 ) -> Union[str, AppDryRunInfo]:
     """Creates a monarch server by submitting it as a job to the target scheduler.
 
@@ -94,7 +95,7 @@ def create(
         from monarch.tools.config import defaults
 
         config = defaults.config(scheduler="slurm")
-        appdef = defaults.component_fn(scheduler=config.scheduler)()
+        config.appdef = defaults.component_fn(scheduler=config.scheduler)()
 
         config.scheduler_args.update(
             {
@@ -105,7 +106,7 @@ def create(
         )
         config.dryrun = True
 
-        create(config, appdef)
+        create(config)
 
 
     Args:
@@ -114,6 +115,7 @@ def create(
         component_fn: a function that returns the AppDef (job def).
             If not provided, defaults to the configured default for the scheduler
             (in most cases ``monarch.tools.components.hyperactor.proc_mesh``)
+        name: the name of the job. If none, a default job name will be created.
     """
     scheduler: str = config.scheduler
     cfg: Mapping[str, CfgVal] = config.scheduler_args
@@ -122,6 +124,8 @@ def create(
     os.environ["TORCHX_CONTEXT_NAME"] = os.getenv("TORCHX_CONTEXT_NAME", "monarch")
 
     with torchx_runner() as runner:
+        appdef: AppDef = AppDef(name, config.appdef.roles, config.appdef.metadata)
+
         info = runner.dryrun(appdef, scheduler, cfg, config.workspace)
 
         info_json_fmt = AppDryRunInfo(
@@ -170,6 +174,8 @@ def info(server_handle: str) -> Optional[ServerSpec]:
         # null-guard since some schedulers do not fill replica_status
         if host_status := replica_status.get(role.name):
             spec.hostnames = [h.hostname for h in host_status]
+            # the mesh status is based on the "least progressive" replica status
+            spec.state = min(h.state for h in host_status)
 
         mesh_specs.append(spec)
 
@@ -211,6 +217,8 @@ async def server_ready(
 
     """
 
+    check_interval_seconds = check_interval.total_seconds()
+    start = datetime.now()
     while True:
         server_spec = info(server_handle)
 
@@ -220,42 +228,56 @@ async def server_ready(
         if server_spec.state <= AppState.PENDING:  # UNSUBMITTED or SUBMITTED or PENDING
             # NOTE: TorchX currently does not have async APIs so need to loop-on-interval
             # TODO maybe inverse exponential backoff instead of constant interval?
-            check_interval_seconds = check_interval.total_seconds()
-            logger.info(
-                "waiting for %s to be %s (current: %s), will check again in %g seconds...",
-                server_handle,
-                AppState.RUNNING,
-                server_spec.state,
-                check_interval_seconds,
+            print(
+                f"Waiting for {server_handle} to be {AppState.RUNNING} (current: {server_spec.state}); "
+                f"will check again in {check_interval_seconds} seconds. "
+                f"Total wait time: {datetime.now() - start}",
+                end="\r",
             )
-            time.sleep(check_interval_seconds)
+            await asyncio.sleep(check_interval_seconds)
             continue
-        else:
-            return server_spec
-
 
+        # check if hosts are allocated for all the meshes
+        if server_spec.state == AppState.RUNNING:
+            running = True
+            for mesh_spec in server_spec.meshes:
+                if mesh_spec.state <= AppState.PENDING:
+                    print(
+                        f"Job {server_handle} is running but waiting for mesh {mesh_spec.name} "
+                        f"to be {AppState.RUNNING} (current: {mesh_spec.state}); "
+                        f"will check again in {check_interval_seconds} seconds. "
+                        f"Total wait time: {datetime.now() - start}",
+                        end="\r",
+                    )
+                    running = False
+                    break
+            if not running:
+                await asyncio.sleep(check_interval_seconds)
+                continue
+
+        return server_spec
+
+
+# TODO: this API is overloaded. Ideally, we do not need config to get or an handle to create.
 async def get_or_create(
     name: str,
     config: Config,
-    appdef: AppDef,
     check_interval: timedelta = _5_SECONDS,
 ) -> ServerSpec:
-    """Waits for the server called `name` in the scheduler specified in the `config`
+    """Waits for the server based on identity `name` in the scheduler specified in the `config`
     to be ready (e.g. RUNNING). If the server is not found then this function creates one
-    per the `appdef` spec, and waits for the server to be ready before returning.
+    per the `config` spec, and waits for the server to be ready before returning.
 
     Usage:
 
     .. code-block:: python
 
-        import getpass
         from monarch.tools.config import defaults
 
-        USER = getpass.getuser()
         config = defaults.config(scheduler)
-        appdef = defaults.component_fn(config.scheduler)()
+        config.appdef = defaults.component_fn(config.scheduler)()
 
-        server_handle = get_or_create(f"{USER}_monarch", config, appdef)
+        server_handle = get_or_create(name="my_job_name", config)
         server_info = info(server_handle)
 
     Returns: A `ServerSpec` containing information about either the existing or the newly
@@ -273,7 +295,7 @@ async def get_or_create(
         )
 
         # no dryrun (see assertion above) support so will always be a handle (str)
-        new_server_handle = str(create(config, appdef))
+        new_server_handle = str(create(config, name))
 
         logger.info(f"created new `{new_server_handle}` waiting for it to be ready...")
 
@@ -289,10 +311,10 @@ async def get_or_create(
                 f"the new server `{new_server_handle}` has {server_info.state}"
             )
 
-        logger.info(f"server `{new_server_handle}` is: {server_info.state}")
+        print(f"\x1b[36mNew job `{new_server_handle}` is ready to serve. \x1b[0m")
         return server_info
     else:
-        logger.info("found existing RUNNING server `%s`", server_handle)
+        print(f"\x1b[36mFound existing job `{server_handle}` ready to serve. \x1b[0m")
         return server_info
 
 

monarch/tools/components/hyperactor.py

@@ -9,6 +9,7 @@ import getpass
 from typing import Optional
 
 from monarch.tools import mesh_spec
+from monarch.tools.config import UnnamedAppDef
 from monarch.tools.mesh_spec import mesh_spec_from_str
 from torchx import specs
 
@@ -16,17 +17,18 @@ _DEFAULT_MESHES = ["mesh_0:1:gpu.small"]
 
 _USER: str = getpass.getuser()
 
+DEFAULT_NAME: str = f"monarch-{_USER}"
+
 __version__ = "latest"  # TODO get version from monarch.__version_
 
 
 def proc_mesh(
-    name: str = f"monarch-{_USER}",
     image: str = f"ghcr.io/pytorch-labs/monarch:{__version__}",  # TODO docker needs to be built and pushed to ghcr
     meshes: list[str] = _DEFAULT_MESHES,
     env: Optional[dict[str, str]] = None,
     port: int = mesh_spec.DEFAULT_REMOTE_ALLOCATOR_PORT,
     program: str = "monarch_bootstrap",  # installed with monarch wheel (as console script)
-) -> specs.AppDef:
+) -> UnnamedAppDef:
     """
     Args:
         name: the name of the monarch server job
@@ -37,7 +39,7 @@ def proc_mesh(
         program: path to the binary that the remote process allocator spawns on an allocation request
     """
 
-    appdef = specs.AppDef(name)
+    appdef = UnnamedAppDef()
 
     for mesh in [mesh_spec_from_str(mesh) for mesh in meshes]:
         mesh_role = specs.Role(

monarch/tools/config/__init__.py

@@ -6,15 +6,32 @@
 
 # pyre-strict
 from dataclasses import dataclass, field
-from typing import Any, Optional
+from typing import Any, Dict, List, Optional
+
+from torchx.specs import Role
 
 
 NOT_SET: str = "__NOT_SET__"
 
 
+@dataclass
+class UnnamedAppDef:
+    """
+    A TorchX AppDef without a name.
+    """
+
+    roles: List[Role] = field(default_factory=list)
+    metadata: Dict[str, str] = field(default_factory=dict)
+
+
 @dataclass
 class Config:
+    """
+    All configs needed to schedule a mesh of allocators.
+    """
+
     scheduler: str = NOT_SET
     scheduler_args: dict[str, Any] = field(default_factory=dict)
     workspace: Optional[str] = None
     dryrun: bool = False
+    appdef: UnnamedAppDef = UnnamedAppDef()

monarch/tools/config/defaults.py

@@ -11,7 +11,7 @@
 from typing import Callable, Optional
 
 from monarch.tools.components import hyperactor
-from monarch.tools.config import Config
+from monarch.tools.config import Config, UnnamedAppDef
 
 from torchx import specs
 from torchx.schedulers import (
@@ -23,7 +23,7 @@ from torchx.schedulers import (
 )
 
 
-def component_fn(scheduler: str) -> Callable[..., specs.AppDef]:
+def component_fn(scheduler: str) -> Callable[..., UnnamedAppDef]:
     """The default TorchX component function for the scheduler"""
     return hyperactor.proc_mesh
 

monarch/tools/mesh_spec.py

@@ -9,6 +9,8 @@ import string
 from dataclasses import dataclass, field
 from typing import Any, Optional
 
+from monarch.tools.config import UnnamedAppDef
+
 from monarch.tools.network import get_sockaddr
 from torchx import specs
 from torchx.specs.api import is_terminal
@@ -39,6 +41,7 @@ class MeshSpec:
     transport: str = "tcp"
     port: int = DEFAULT_REMOTE_ALLOCATOR_PORT
     hostnames: list[str] = field(default_factory=list)
+    state: specs.AppState = specs.AppState.UNSUBMITTED
 
     def server_addrs(
         self, transport: Optional[str] = None, port: Optional[int] = None
@@ -69,7 +72,7 @@ def _tag(mesh_name: str, tag_template: str) -> str:
     return string.Template(tag_template).substitute(mesh_name=mesh_name)
 
 
-def tag_as_metadata(mesh_spec: MeshSpec, appdef: specs.AppDef) -> None:
+def tag_as_metadata(mesh_spec: MeshSpec, appdef: UnnamedAppDef) -> None:
     appdef.metadata[_tag(mesh_spec.name, _TAG_HOST_TYPE)] = mesh_spec.host_type
     appdef.metadata[_tag(mesh_spec.name, _TAG_GPUS)] = str(mesh_spec.gpus)
     appdef.metadata[_tag(mesh_spec.name, _TAG_TRANSPORT)] = mesh_spec.transport

tests/test_allocator.py

@@ -33,7 +33,6 @@ from monarch._rust_bindings.monarch_hyperactor.channel import (
     ChannelTransport,
 )
 
-from monarch._src.actor.actor_mesh import MonarchContext
 from monarch._src.actor.allocator import (
     ALLOC_LABEL_PROC_MESH_NAME,
     LocalAllocator,
@@ -160,7 +159,7 @@ class TestSetupActorInAllocator(unittest.IsolatedAsyncioTestCase):
             "TEST_ENV_VAR_3": "value_3",
         }
 
-        def setup_multiple_env_vars(ctx: MonarchContext) -> None:
+        def setup_multiple_env_vars() -> None:
             for name, value in env_vars.items():
                 os.environ[name] = value
 
@@ -184,36 +183,33 @@ class TestSetupActorInAllocator(unittest.IsolatedAsyncioTestCase):
             await proc_mesh.stop()
 
     async def test_setup_lambda_with_context_info(self) -> None:
-        """Test that the setup lambda can access context information"""
-        context_var_name: str = "PROC_MESH_CONTEXT_INFO"
+        """Test that the setup lambda can access rank information"""
+        context_var_name: str = "PROC_MESH_RANK_INFO"
 
-        def setup_with_context(ctx: MonarchContext) -> None:
-            context_info = f"proc_id:{ctx.proc_id},point_rank:{ctx.point.rank}"
+        def setup_with_rank() -> None:
+            context_info = f"point_rank:{current_rank().rank}"
             os.environ[context_var_name] = context_info
 
         spec = AllocSpec(AllocConstraints(), gpus=1, hosts=1)
         allocator = LocalAllocator()
         alloc = await allocator.allocate(spec)
 
-        proc_mesh = await ProcMesh.from_alloc(alloc, setup=setup_with_context)
+        proc_mesh = await ProcMesh.from_alloc(alloc, setup=setup_with_rank)
 
         try:
             actor = await proc_mesh.spawn("env_check", EnvCheckActor)
 
-            context_info = await actor.get_env_var.call_one(context_var_name)
+            rank_info = await actor.get_env_var.call_one(context_var_name)
 
             self.assertNotEqual(
-                context_info,
+                rank_info,
                 "NOT_SET",
                 "Context information was not stored in the environment variable",
             )
-            self.assertIn(
-                "proc_id:", context_info, "Context information does not contain proc_id"
-            )
             self.assertIn(
                 "point_rank:0",
-                context_info,
-                f"Context information {context_info} does not contain point_rank",
+                rank_info,
+                f"Context information {rank_info} does not contain point_rank",
             )
         finally:
             await proc_mesh.stop()
@@ -435,7 +431,7 @@ class TestRemoteAllocator(unittest.IsolatedAsyncioTestCase):
         test_var_name: str = "TEST_ENV_VAR_FOR_PROC_MESH"
         test_var_value: str = "test_value_123"
 
-        def setup_env_vars(ctx: MonarchContext) -> None:
+        def setup_env_vars() -> None:
             os.environ[test_var_name] = test_var_value
 
         hosts = 2

tests/test_env_before_cuda.py

@@ -15,7 +15,6 @@ import cloudpickle
 
 import torch
 from monarch._rust_bindings.monarch_hyperactor.alloc import AllocConstraints, AllocSpec
-from monarch._src.actor.actor_mesh import MonarchContext
 from monarch._src.actor.allocator import LocalAllocator
 from monarch._src.actor.proc_mesh import proc_mesh
 from monarch.actor import Actor, endpoint, ProcMesh
@@ -70,7 +69,7 @@ class TestEnvBeforeCuda(unittest.IsolatedAsyncioTestCase):
             "CUDA_LAUNCH_BLOCKING": "1",
         }
 
-        def setup_cuda_env(_: MonarchContext) -> None:
+        def setup_cuda_env() -> None:
             for name, value in cuda_env_vars.items():
                 os.environ[name] = value
 
@@ -107,7 +106,7 @@ class TestEnvBeforeCuda(unittest.IsolatedAsyncioTestCase):
             "CUDA_DEVICE_MAX_CONNECTIONS": "1",
         }
 
-        def setup_cuda_env(_: MonarchContext) -> None:
+        def setup_cuda_env() -> None:
             for name, value in cuda_env_vars.items():
                 os.environ[name] = value
 

tests/test_python_actors.py

@@ -586,3 +586,15 @@ class TestActorMeshStop(unittest.IsolatedAsyncioTestCase):
 
         await am_2.print.call("hello 3")
         await am_2.log.call("hello 4")
+
+
+class PortedActor(Actor):
+    @endpoint(explicit_response_port=True)
+    def add(self, port: "Port[int]", b: int) -> None:
+        port.send(3 + b)
+
+
+def test_ported_actor():
+    proc_mesh = local_proc_mesh(gpus=1).get()
+    a = proc_mesh.spawn("port_actor", PortedActor).get()
+    assert 5 == a.add.call_one(2).get()

tests/test_tensor_engine.py

@@ -8,7 +8,7 @@ import monarch
 import pytest
 import torch
 from monarch import remote
-from monarch.actor import Actor, endpoint, proc_mesh
+from monarch.actor import Actor, as_endpoint, endpoint, proc_mesh
 from monarch.mesh_controller import spawn_tensor_engine
 
 
@@ -104,3 +104,29 @@ def test_actor_tensor_ordering() -> None:
             results.append(counter.incr.call(1))
 
         assert list(range(10)) == [r.get().item(hosts=0, gpus=0) for r in results]
+
+
+class Linear(Actor):
+    def __init__(self, N: int, M: int):
+        self.weight = torch.zeros((N, M))
+
+    def forward(self, x) -> torch.Tensor:
+        return x @ self.weight
+
+    @endpoint(propagate="inspect")
+    def update(self, w: torch.Tensor) -> None:
+        self.weight += w
+
+
+@two_gpu
+def test_rref_actor() -> None:
+    pm = proc_mesh(gpus=1).get()
+    with pm.activate():
+        x = pm.spawn("linear", Linear, 3, 4).get()
+
+        y = torch.ones((4, 3))
+        t = as_endpoint(x.forward, propagate=lambda x: torch.rand(3, 4)).rref(y)
+        assert monarch.inspect(t.sum()).item() == 0
+        x.update.rref(torch.ones((3, 4)))
+        t = as_endpoint(x.forward, propagate=lambda x: torch.rand(3, 4)).rref(y)
+        assert monarch.inspect(t.sum()).item() == 3 * 4 * 4

{torchmonarch_nightly-2025.7.25.dist-info → torchmonarch_nightly-2025.7.27.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: torchmonarch-nightly
-Version: 2025.7.25
+Version: 2025.7.27
 Summary: Monarch: Single controller library
 Author: Meta
 Author-email: oncall+monarch@xmail.facebook.com
@@ -44,6 +44,8 @@ Note: Monarch is currently only supported on Linux systems
 
 ## Installation
 
+### On Fedora distributions
+
 `pip install torchmonarch-nightly`
 
 or manually
@@ -88,6 +90,37 @@ pip install --no-build-isolation -e .
 pytest python/tests/ -v -m "not oss_skip"
 ```
 
+### On MacOS
+
+You can also build Monarch to run locally on a MacOS system.
+
+Note that this does not support tensor engine, which is tied to CUDA and RDMA (via ibverbs).
+
+
+```sh
+
+# Create and activate the conda environment
+conda create -n monarchenv python=3.10 -y
+conda activate monarchenv
+
+# Install nightly rust toolchain
+curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+rustup toolchain install nightly
+rustup default nightly
+
+# Install build dependencies
+pip install -r build-requirements.txt
+# Install test dependencies
+pip install -r python/tests/requirements.txt
+
+# Build and install Monarch
+USE_TENSOR_ENGINE=0 pip install --no-build-isolation .
+# or setup for development
+USE_TENSOR_ENGINE=0 pip install --no-build-isolation -e .
+
+```
+
+
 ## Running examples
 
 Check out the `examples/` directory for demonstrations of how to use Monarch's APIs.