Move the engine core into core/, a project of its own (pplus-core)

What programs mean (the languages, translators, Mojo checker and
interpreter, prover, fuzzer, machine model, catalog problems and the Mojo
corpus with godbolt's stored answers) was mixed into the site's tree, so a
change to the prover and a change to a button went through the same gate
and the same docs. This moves all of it under core/, laid out as its own
repository, ready to be extracted with its history and pinned here as a
git submodule.

- core/: src/{engines,services,sync,mojo,exercises,curriculum,common},
  mojo/, syntax/mojo.xml, its tests (with Workspace and workForProblem in
  place of the site's Session), scripts (corpus pipeline, play, the
  exercise and probe starters, engines export/diff), and its docs
  (engines, trust, mojo-corpus, exercises, coverage). Its own pixi.toml,
  package.json, README, AGENTS.md and CI workflow.
- core/tests/boundary.test.mjs: library modules use no DOM, import no
  page widget, and import nothing outside src/.
- core/scripts/cli.mjs: pixi run cli check|run|prove|fuzz|translate.
- core/scripts/dafny.py: Dafny 4.11.0 pinned by version and SHA-256 per
  platform, fetched into .tools/ (pixi run dafny-fetch, pixi run dafny).
- The site imports core only as #core/<path>.js: an import map in
  index.html, "imports" in package.json for node, core's declarations for
  tsc. The site's TypeScript builds core first (npm run build).
- assemble.sh, the Quarto engine copy, the render cache key, check-pages,
  quarto-export and quarto-css read core/dist and core/mojo; quarto-css
  copies core's syntax/mojo.xml into the extension.
- Site tests that covered engines moved to core; the rest keep Session.
- README, AGENTS.md, docs/app.md, docs/deploy.md and the CI workflow
  describe the split (checkout with submodules; core's tests and corpus
  status run against the pinned commit).

Gate: site 110 pass; core 307 pass; corpus status --strict passes.
Manual check: the assembled site opens Bridge (count-base-proved),
Developer and Hardware (count-base) with the editor, the stepper and the
board, and no module errors.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FgvbRdoEheAHqsRmr2WuKZ
This commit is contained in:
alexmandClaude committed 2026-10-05 05:43:58 +00:00
1 parent f43bbfe0cf
commit 82e18f7966
1567 files changed
+3670 -981

No files matched your search

File diff suppressed because it is too large. Load diff
@@ -0,0 +1,19 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: Every Mojo program must include a function named `main()` as the entry point
def boot():
print("MQ Robotics control daemon starting")
def main():
boot()
@@ -0,0 +1,15 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: Code blocks such as functions, conditions, and loops are defined with a colon followed by indented lines
def main():
print("MQ Robotics nav stack online")
@@ -0,0 +1,19 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: Mojo uses the `def` keyword to define functions
def heartbeat() -> String:
return "heartbeat ok"
def main():
print(heartbeat())
@@ -0,0 +1,19 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: You must declare the type of each function parameter and argument; the return type follows `->`
def grid_cells(rows: Int, cols: Int) -> Int:
return rows * cols
def main():
print("Grid cells:", grid_cells(3, 4))
@@ -0,0 +1,22 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: Values are passed back using the `return` keyword; the return type is declared with the `-> type` syntax
# Ring-buffer helpers for the sensor ingest loop
def grow_capacity(n: Int) -> Int:
return n * 2
def main():
print("New capacity:", grow_capacity(21))
@@ -0,0 +1,20 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: A docstring is a string literal in triple quotes placed as the first statement in a function body
def log_command(name: String) -> String:
"""Return a log line announcing the command being dispatched."""
return "Dispatching command: " + name
def main():
print(log_command("rotate-90"))
@@ -0,0 +1,19 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: Keyword arguments are specified using `argument_name = argument_value` and can be passed in any order
def set_limits(max_speed: Int, max_accel: Int):
print("speed:", max_speed, "accel:", max_accel)
def main():
set_limits(max_speed=2, max_accel=5)
@@ -0,0 +1,19 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: An optional argument includes a default value, and must appear after any required arguments
def spin_up(rpm: Int, ramp_ms: Int = 100) -> Int:
return rpm + ramp_ms
def main():
print("total:", spin_up(900))
@@ -0,0 +1,21 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: A single star (`*`) in the argument list marks the following arguments as keyword-only
def run_diagnostic(name: String, *, verbose: Bool) -> String:
if verbose:
return name + " [verbose]"
return name
def main():
print(run_diagnostic("imu", verbose=True))
@@ -0,0 +1,22 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: Use the variadic argument syntax `*argument_name` to accept a variable number of arguments
def total(*readings: Int) -> Int:
var s = 0
for r in readings:
s += r
return s
def main():
print("sum:", total(3, 4, 5))
@@ -0,0 +1,21 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: Use `pass` as a no-op placeholder when a block requires a body but has nothing to do
def run_self_test():
# TODO: implement the real self-test later; this is just a stub
pass
def main():
run_self_test()
print("self-test stub ran")
@@ -0,0 +1,23 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: Implement separate versions of a function with different argument types to "overload" it
def footprint(side: Int) -> Int:
return side * side
def footprint(w: Int, h: Int) -> Int:
return w * h
def main():
print(footprint(4), footprint(2, 3))
@@ -0,0 +1,21 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: Functions are non-raising by default; add the `raises` keyword to propagate an error to the caller
def read_sensor(id: Int) raises -> Int:
if id < 0:
raise Error("bad sensor id")
return id * 10
def main() raises:
print("reading:", read_sensor(2))
@@ -0,0 +1,17 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: Explicitly-declared variables are created with the `var` keyword
def main():
var tick_count = 0
tick_count += 1
print("Ticks processed:", tick_count)
@@ -0,0 +1,17 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: Late initialization works only if the variable is declared with a type
def main():
var threshold: Int
threshold = 10
print("threshold:", threshold)
@@ -0,0 +1,16 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: Since variables are strongly typed, you can't assign a value of a different type
def main():
var count: Int = 5
print("count:", count)
@@ -0,0 +1,18 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: A variable owns its value; ownership is transferred with the `^` sigil, which leaves the source uninitialized
def main():
var a: List[Int] = [1, 2, 3]
var b = a.copy()
a.append(4)
print("a:", len(a), "b:", len(b))
@@ -0,0 +1,18 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: Use the `ref name` syntax to bind a reference to a value rather than an owned copy
def main():
var readings: List[Int] = [10, 20, 30]
ref first = readings[0]
first = 99
print("first:", readings[0])
@@ -0,0 +1,19 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: Numeric operators don't automatically narrow or widen operands to a common type
def widen_add(reading: Int8, total: Int64) -> Int64:
return Int64(reading) + total
def main():
print("total:", widen_add(100, 1000))
@@ -0,0 +1,19 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: Convert the operands to the target type's constructor before dividing to avoid integer truncation
def avg_latency(total_ms: Int, num_loops: Int) -> Float64:
return Float64(total_ms) / Float64(num_loops)
def main():
print("avg latency:", avg_latency(7, 2))
@@ -0,0 +1,19 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: A `SIMD` value is a fixed-size vector defined by two parameters: a `DType` and the number of elements
comptime Velocity = SIMD[.float32, 4]
def main():
var v = Velocity(1.0, 2.0, 3.0, 4.0)
print("Velocity lane 0:", v[0])
@@ -0,0 +1,21 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: Math operations on SIMD values are applied elementwise, on each individual element in the vector
def combine_counts(a: SIMD[.int32, 4], b: SIMD[.int32, 4]) -> SIMD[.int32, 4]:
return a + b
def main():
var imu_a = SIMD[.int32, 4](1, 2, 3, 4)
var imu_b = SIMD[.int32, 4](10, 20, 30, 40)
print("Combined counts:", combine_counts(imu_a, imu_b))
@@ -0,0 +1,19 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: `String` supports a variety of operators and common methods, such as `upper()`
def device_tag(family: String, model: String) -> String:
return (family + "-" + model).upper()
def main():
print(device_tag("mq", "amr"))
@@ -0,0 +1,18 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: Index a `List` with `list[i]` to read an element; assign to `list[i]` to replace it in place
def main():
var path: List[Int] = [10, 20, 30]
path[0] = 15
print("first waypoint:", path[0])
print("waypoints:", len(path))
@@ -0,0 +1,25 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: A `Tuple` is an ordered collection; unpack it or index it to get individual values
def scan_stats() -> Tuple[Int, Int]:
var num_scans = 4
var total_points = 512
return (num_scans, total_points)
def main():
var stats = scan_stats()
var scans = stats[0]
var points = stats[1]
print("scans:", scans)
print("points:", points)
@@ -0,0 +1,18 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: A given `List` can only hold one type of value, specified at compile time as a parameter
def main():
var waypoints = List[Int]()
waypoints.append(128)
waypoints.append(256)
print("Queued waypoints:", len(waypoints))
@@ -0,0 +1,22 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: `Dict` holds key-value pairs; specify the key type and value type as parameters
from std.collections import Dict
def main() raises:
var joint_angles = Dict[String, Int]()
joint_angles["joint_3"] = 128
joint_angles["joint_8"] = 256
print("joint angle:", joint_angles["joint_3"])
print("joints:", len(joint_angles))
@@ -0,0 +1,22 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: `Set` represents a collection of unique values
from std.collections import Set
def main():
var seen = Set[Int]()
seen.add(1)
seen.add(1)
seen.add(2)
print("unique:", len(seen))
@@ -0,0 +1,33 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: An `Optional` represents a value that may or may not be present
from std.collections import Optional
def cache_lookup(sensor_id: Int) -> Optional[Int]:
if sensor_id == 7:
return 512
return None
def main() raises:
var hit = cache_lookup(7)
var miss = cache_lookup(3)
if hit:
print("hit:", hit.value())
else:
print("hit:", hit)
if miss:
print("miss:", miss.value())
else:
print("miss:", miss)
@@ -0,0 +1,19 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: Exponentiation uses two stars (`**`), not a caret
def square_area(side: Int) -> Int:
return side**2
def main():
print("area:", square_area(4))
@@ -0,0 +1,20 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: Use `//` for floor division; the modulo operator `%` returns the remainder
def split_into_bins(total: Int, per_bin: Int) -> Tuple[Int, Int]:
return total // per_bin, total % per_bin
def main():
var result = split_into_bins(17, 5)
print("bins:", result[0], "left:", result[1])
@@ -0,0 +1,19 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: Mojo provides six comparison operators: `==`, `!=`, `<`, `<=`, `>`, and `>=`, each returning a `Bool`
def battery_low(level: Int) -> Bool:
return level <= 20
def main():
print("low:", battery_low(20))
@@ -0,0 +1,19 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: You can chain comparisons; `a < b < c` is equivalent to `(a < b) and (b < c)`
def in_range(temp: Int) -> Bool:
return 0 <= temp <= 85
def main():
print("in range:", in_range(90))
@@ -0,0 +1,22 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: Bitwise OR (`|`) keeps bits that are set in either operand
def status_word(ready: Int, armed: Int) -> Int:
return ready | armed
def main():
var READY = 1
var ARMED = 2
var flags = status_word(READY, ARMED)
print("armed:", (flags & ARMED) != 0)
@@ -0,0 +1,19 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: With `and`, both operands must be truthy; if the left side is falsy, the right side isn't evaluated
def can_drive(has_fix: Bool, calibrated: Bool) -> Bool:
return has_fix and calibrated
def main():
print("go:", can_drive(True, False))
@@ -0,0 +1,20 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: The `in` operator checks whether a collection contains a value
def is_allowed(sensor_id: Int, allowed: List[Int]) -> Bool:
return sensor_id in allowed
def main():
var allowed: List[Int] = [2, 4, 6]
print("ok:", is_allowed(4, allowed))
@@ -0,0 +1,19 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: A conditional expression has the form `value_if_true if condition else value_if_false`
def speed_label(speed: Int) -> String:
return "fast" if speed > 10 else "slow"
def main():
print("mode:", speed_label(12))
@@ -0,0 +1,17 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: Compound assignment forms like `*=` update the left-hand value instead of creating a new one
def main():
var scale = 2
scale *= 3
print("scale:", scale)
@@ -0,0 +1,20 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: Precedence determines what runs first (multiply before add); when in doubt, use parentheses
def path_cost(setup: Int, per_segment: Int, segments: Int) -> Int:
# setup plus per-segment cost, then multiplied across the segments
return (setup + per_segment) * segments
def main():
print("Total distance:", path_cost(2, 3, 4))
@@ -0,0 +1,23 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: The `if` statement executes an indented block when its boolean expression evaluates to `True`
def route_task(queue_depth: Int) -> String:
if queue_depth > 100:
return "overflow-core"
else:
return "fast-core"
def main():
print(route_task(250))
print(route_task(40))
@@ -0,0 +1,20 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: The `while` loop repeatedly executes a block while its boolean expression evaluates to `True`
def main():
var attempt = 1
var total = 0
while attempt <= 5:
total += attempt
attempt += 1
print("Retry budget:", total)
@@ -0,0 +1,20 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: In a `for` loop, `continue` skips the rest of the block and resumes with the next element
def main():
var total = 0
for i in range(1, 10):
if i % 3 == 0:
continue
total += i
print("Scheduled units:", total)
@@ -0,0 +1,26 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: Use `elif` to add another condition to an `if`, checked only when the earlier branches were false
def power_mode(level: Int) -> String:
if level >= 80:
return "boost"
elif level >= 30:
return "cruise"
else:
return "sleep"
def main():
print(power_mode(95))
print(power_mode(50))
print(power_mode(10))
@@ -0,0 +1,18 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: A range is a sequence of integers generated by `range(start, stop, step)`
def main():
var total = 0
for i in range(0, 10, 2):
total += i
print("total:", total)
@@ -0,0 +1,18 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: Add the `ref` keyword before the loop variable to bind a reference and mutate the collection in place
def main():
var readings: List[Int] = [1, 2, 3]
for ref r in readings:
r += 10
print("first:", readings[0])
@@ -0,0 +1,23 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: All collection types in the `collections` module support `for` loop iteration over each element
def total_points(batch: List[Int]) -> Int:
var total = 0
for count in batch:
total += count
return total
def main():
var batch: List[Int] = [12, 8, 20, 5]
print("total points:", total_points(batch))
@@ -0,0 +1,21 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: By declaring `raises`, you tell Mojo a function may raise an error; raise one with `raise Error("...")`
def validate_velocity(n: Int) raises -> Int:
if n <= 0:
raise Error("velocity must be positive")
return n
def main() raises:
print("Validated:", validate_velocity(256))
@@ -0,0 +1,24 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: Mojo uses `try`/`except` to detect and handle errors
def checked(n: Int) raises -> Int:
if n < 0:
raise Error("negative reading")
return n
def main():
try:
print("value:", checked(-1))
except:
print("value: 0")
@@ -0,0 +1,26 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: To re-raise a caught error, use `raise` with the `^` sigil to transfer ownership of the error value
def attempt() raises:
try:
raise Error("sensor fault")
except e:
print("logging:", e)
raise e^
def main():
try:
attempt()
except:
print("recovered")
@@ -0,0 +1,20 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: A `with` statement context manager releases its resource at the end of the block, even if an error occurs
def main() raises:
# MQ Robotics stores the active calibration profile on disk.
with open("calib.txt", "w") as f:
f.write("max_speed=1.5")
with open("calib.txt", "r") as f:
print(f.read())
@@ -0,0 +1,28 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: All struct fields are declared with `var` and a type annotation, and must be initialized in the constructor
struct LidarScan(Copyable, Movable):
var near_points: Int
var far_points: Int
def __init__(out self, near_points: Int, far_points: Int):
self.near_points = near_points
self.far_points = far_points
def total(self) -> Int:
return self.near_points + self.far_points
def main():
var scan = LidarScan(8, 256)
print("Total points:", scan.total())
@@ -0,0 +1,26 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: An instance method takes `self` as an explicit first argument, letting it act on a particular instance of the struct
struct Battery:
var charge: Int
def __init__(out self, charge: Int):
self.charge = charge
def is_low(self) -> Bool:
return self.charge < 20
def main():
var b = Battery(15)
print("low:", b.is_low())
@@ -0,0 +1,31 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: To let a method mutate the instance, declare its receiver as `mut self`
struct FrameCounter(Copyable, Movable):
var count: Int
def __init__(out self, count: Int):
self.count = count
def increment(mut self):
self.count += 1
def get(self) -> Int:
return self.count
def main():
var counter = FrameCounter(0)
counter.increment()
counter.increment()
print("Frames handled:", counter.get())
@@ -0,0 +1,21 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: A `@staticmethod` can be called without an instance and doesn't receive `self`, so it can't access fields
struct Encoder:
@staticmethod
def ticks_per_rev() -> Int:
return 4096
def main():
print("ppr:", Encoder.ticks_per_rev())
@@ -0,0 +1,25 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: The `@fieldwise_init` decorator generates a field-wise constructor, so you don't have to write `__init__` by hand
@fieldwise_init
struct LidarScan(Copyable, Movable):
var near_points: Int
var far_points: Int
def total(self) -> Int:
return self.near_points + self.far_points
def main():
var scan = LidarScan(8, 256)
print("Total points:", scan.total())
@@ -0,0 +1,27 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: A move-only type is `Movable` but not `Copyable`; transfer it with the `^` sigil
struct FileHandle(Movable):
var fd: Int
def __init__(out self, fd: Int):
self.fd = fd
def take(var h: FileHandle) -> Int:
return h.fd
def main():
var h = FileHandle(3)
print("fd:", take(h^))
@@ -0,0 +1,28 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: Mojo evaluates `a + b` by calling `a.__add__(b)`
struct EnergyBudget(Copyable, Movable):
var millijoules: Int
def __init__(out self, millijoules: Int):
self.millijoules = millijoules
def __add__(self, other: Self) -> Self:
return Self(self.millijoules + other.millijoules)
def main():
var drive_budget = EnergyBudget(100)
var sense_budget = EnergyBudget(56)
var total = drive_budget + sense_budget
print("combined budget:", total.millijoules)
@@ -0,0 +1,27 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: A unary operator like `-x` calls `__neg__()`, returning a new value representing the result
struct Offset(Copyable, Movable):
var v: Int
def __init__(out self, v: Int):
self.v = v
def __neg__(self) -> Self:
return Self(-self.v)
def main():
var o = Offset(5)
var n = -o
print("neg:", n.v)
@@ -0,0 +1,27 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: Implement `__eq__()` to support `==`; the `Equatable` trait provides `__eq__()` and `__ne__()`
struct Version(Copyable, Movable):
var major: Int
def __init__(out self, major: Int):
self.major = major
def __eq__(self, other: Self) -> Bool:
return self.major == other.major
def main():
var a = Version(2)
var b = Version(2)
print("equal:", a == b)
@@ -0,0 +1,34 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: Implement `__getitem__()` to support subscript reads (`obj[i]`)
struct Frame(Copyable, Movable):
var a: Int
var b: Int
var c: Int
def __init__(out self, a: Int, b: Int, c: Int):
self.a = a
self.b = b
self.c = c
def __getitem__(self, i: Int) -> Int:
if i == 0:
return self.a
if i == 1:
return self.b
return self.c
def main():
var f = Frame(10, 20, 30)
print("channel 1:", f[1])
@@ -0,0 +1,19 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: `from module import name` imports a specific member from a module
from std.math import sqrt
def main():
var root = sqrt(144.0)
print("Square root:", root)
@@ -0,0 +1,22 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: Arguments are read-only by default; the `mut` convention lets the function write back to the caller's value
def record_sample(mut total: Int, sample: Int):
total += sample
def main():
var total = 0
record_sample(total, 12)
record_sample(total, 8)
print("Total distance:", total)
@@ -0,0 +1,21 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: The `^` transfer sigil ends a variable's lifetime and transfers ownership into a `var` argument
def load_map(var cells: List[Int]) -> Int:
return len(cells)
def main():
var cells: List[Int] = [16, 32, 64, 128]
var result = load_map(cells^)
print("map cells loaded:", result)
@@ -0,0 +1,28 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: A `ref` return value must name an origin; it returns a reference to an existing value, not a copy
struct CommandQueue(Copyable, Movable):
var depth: Int
def __init__(out self, depth: Int):
self.depth = depth
def borrow_depth(ref self) -> ref[self.depth] Int:
return self.depth
def main():
var q = CommandQueue(4)
ref d = q.borrow_depth()
d = 10
print("queue depth:", q.depth)
@@ -0,0 +1,25 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: By the end of a constructor, all of the struct's fields must be initialized
struct Waypoint(Copyable, Movable):
var x: Int
var y: Int
def __init__(out self, x: Int, y: Int):
self.x = x
self.y = y
def main():
var w = Waypoint(3, 7)
print("y:", w.y)
@@ -0,0 +1,33 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: Like any method, `__init__()` can be overloaded to construct the object from different arguments
struct RobotConfig(Copyable, Movable):
var name: String
var max_rate: Int
def __init__(out self, name: String, max_rate: Int):
self.name = name
self.max_rate = max_rate
# Re-badge an existing config under a new name, keeping its rate. This takes
# a different second-argument type than the constructor above, so it must be
# a separate overload — a default argument couldn't express both forms.
def __init__(out self, name: String, template: Self):
self.name = name
self.max_rate = template.max_rate
def main():
var base = RobotConfig("base", 512)
var arm = RobotConfig("arm", base)
print("Robot:", arm.name, "max_rate:", arm.max_rate)
@@ -0,0 +1,27 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: An `@implicit` single-argument constructor enables implicit conversion from the source type
struct Celsius(Copyable, Movable):
var deg: Int
@implicit
def __init__(out self, deg: Int):
self.deg = deg
def report(t: Celsius):
print("temp:", t.deg)
def main():
report(25)
@@ -0,0 +1,33 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: Conforming to `Copyable` gives a type a compiler-synthesized `.copy()` method
struct ScanBuffer(Copyable):
var samples: List[Int]
def __init__(out self, var samples: List[Int]):
self.samples = samples^
def push(mut self, t: Int):
self.samples.append(t)
def size(self) -> Int:
return len(self.samples)
def main():
var original: List[Int] = [1, 2, 3]
var snapshot = ScanBuffer(original^)
var working = snapshot.copy()
working.push(99)
print("snapshot size:", snapshot.size())
print("working size:", working.size())
@@ -0,0 +1,24 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: The `ImplicitlyCopyable` trait lets the compiler copy a value on a plain assignment (`var b = a`)
struct Reading(ImplicitlyCopyable, Movable):
var v: Int
def __init__(out self, v: Int):
self.v = v
def main():
var a = Reading(5)
var b = a
print("a:", a.v, "b:", b.v)
@@ -0,0 +1,32 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: Mojo calls a value's `__deinit__()` destructor when its lifetime ends (ASAP, last-use destruction)
struct MotorHandle:
var motor_id: Int
def __init__(out self, motor_id: Int):
self.motor_id = motor_id
print("Acquired motor", self.motor_id)
def __deinit__(deinit self):
print("Released motor", self.motor_id)
def drive():
var handle = MotorHandle(0)
print("Driving with motor", handle.motor_id)
def main():
drive()
print("Scheduler idle")
@@ -0,0 +1,16 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: Assign an expression to a compile-time constant with `comptime`, which evaluates it once at compile time
def main():
comptime tick_budget = 50 * 20
print("tick budget:", tick_budget)
@@ -0,0 +1,21 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: `comptime for` fully unrolls a loop at compile time over a compile-time sequence like `range(LIMIT)`
comptime NUM_AXES = 4
def main():
var total = 0
comptime for i in range(NUM_AXES):
total += i
print("axis sum:", total)
@@ -0,0 +1,19 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: Parameters in `[]` are compile-time inputs; arguments in `()` are run-time values
def scale[factor: Int](x: Int) -> Int:
return x * factor
def main():
print("Scaled:", scale[3](14))
@@ -0,0 +1,25 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: A parameterized struct adds compile-time parameters in `[]` after its name; they are accessible on instances (e.g. `b.size`)
struct Buffer[size: Int](Copyable, Movable):
def __init__(out self):
pass
def capacity(self) -> Int:
return Self.size
def main():
var b = Buffer[8]()
print("capacity:", b.capacity())
print("size:", b.size)
@@ -0,0 +1,34 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: Declare trait conformance in parentheses after the struct name; the compiler enforces the trait's requirements
trait Sensor:
def read(self) -> String:
...
struct Lidar(Sensor):
var name: String
def __init__(out self, name: String):
self.name = name
def read(self) -> String:
return "Reading from " + self.name
def announce[T: Sensor](sensor: T):
print(sensor.read())
def main():
announce(Lidar("lidar-front"))
@@ -0,0 +1,32 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: A trait can include a default method implementation that conforming structs inherit unless they override it
trait Greeter:
def name(self) -> String:
...
def greet(self) -> String:
return "hello " + self.name()
struct Robot(Greeter):
def __init__(out self):
pass
def name(self) -> String:
return "amr"
def main():
var r = Robot()
print(r.greet())
@@ -0,0 +1,28 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: The `Sized` trait requires a type to implement `__len__()`, which the built-in `len()` function uses
struct Track(Sized):
var name: String
var waypoints: List[Int]
def __init__(out self, name: String, var waypoints: List[Int]):
self.name = name
self.waypoints = waypoints^
def __len__(self) -> Int:
return len(self.waypoints)
def main():
var t = Track("loop-a", [10, 20, 30, 40, 50])
print("len:", len(t))
@@ -0,0 +1,21 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: `Some[Trait]` is shorthand for a trait-constrained generic parameter; `def f(v: Some[Writable])` is equivalent to `def f[T: Writable](v: T)`
# Logs any value the telemetry bus touches, whatever its type.
def log_value(value: Some[Writable]):
print("telemetry:", value)
def main():
log_value(42)
log_value("ready")
@@ -0,0 +1,21 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: `comptime assert cond, "msg"` asserts a condition at compile time; if false, compilation fails
def make_drive[num_motors: Int]() -> Int:
# The drive train must pair motors across an even motor count.
comptime assert num_motors % 2 == 0, "num_motors must be even"
return num_motors * 64
def main():
print("Drive slots:", make_drive[8]())
@@ -0,0 +1,23 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: The `comptime` keyword forces an expression to be evaluated at compile time
comptime dim = 8
def transform_size[dim: Int]() -> Int:
# a dim x dim transform matrix has dim * dim entries
return dim * dim
def main():
print("matrix entries:", transform_size[dim]())
@@ -0,0 +1,27 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: Use `reflect[T]` to inspect a type at compile time, querying members like `field_count()`
struct RobotConfig(Copyable, Movable):
var max_speed: Int
var wheel_radius: Int
var num_sensors: Int
def __init__(out self, max_speed: Int, wheel_radius: Int, num_sensors: Int):
self.max_speed = max_speed
self.wheel_radius = wheel_radius
self.num_sensors = num_sensors
def main():
comptime field_count = reflect[RobotConfig].field_count()
print("RobotConfig fields:", field_count)
@@ -0,0 +1,24 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: Use the free function `unsafe_alloc[T](n)` to allocate space for `n` uninitialized values of `T`
from std.memory.alloc import unsafe_alloc
def main():
# Stage a single encoder reading in a scratch buffer.
var ptr = unsafe_alloc[Int](1)
ptr.unsafe_write(copy=99)
var value = ptr[]
print("Encoder count:", value)
ptr.unsafe_deinit_pointee()
ptr.unsafe_free()
@@ -0,0 +1,19 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: With space for multiple values, `ptr[unsafe_offset=i]` accesses the element at offset `i`
def main():
var ptr = alloc[Int]({count = 2}).unsafe_leak()
ptr[unsafe_offset=0] = 10
ptr[unsafe_offset=1] = 20
print("second:", ptr[unsafe_offset=1])
ptr.unsafe_free()
@@ -0,0 +1,23 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: `assert_equal` from the `testing` module asserts that two values are equal
from std.testing import assert_equal
def total_distance(near: Int, far: Int) -> Int:
return near + far
def main() raises:
assert_equal(total_distance(100, 50), 150)
print("All checks passed!")
@@ -0,0 +1,26 @@
# ===----------------------------------------------------------------------=== #
# Copyright (c) 2026, Modular Inc. All rights reserved.
#
# Licensed under the Apache License v2.0 with LLVM Exceptions:
# https://llvm.org/LICENSE.txt
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===----------------------------------------------------------------------=== #
# Mojo concept: `assert_raises` from the `testing` module is a context manager that asserts its `with` block raises an error
from std.testing import assert_raises
def clamp(n: Int) raises -> Int:
if n < 0:
raise Error("negative speed")
return n
def main() raises:
with assert_raises():
_ = clamp(-1)
print("raised as expected")
@@ -0,0 +1,2 @@
def boot():
print("MQ Robotics control daemon starting")
@@ -0,0 +1,2 @@
def main():
print("MQ Robotics nav stack online")
@@ -0,0 +1,6 @@
heartbeat() -> String:
return "heartbeat ok"
def main():
print(heartbeat())
@@ -0,0 +1,6 @@
def grid_cells(rows, cols):
return rows * cols
def main():
print("Grid cells:", grid_cells(3, 4))
@@ -0,0 +1,8 @@
# Ring-buffer helpers for the sensor ingest loop
def grow_capacity(n: Int) -> Int:
return n # TODO: should double the buffer's capacity
def main():
print("New capacity:", grow_capacity(21))
@@ -0,0 +1,6 @@
def log_command(name: String) -> String:
return "Dispatching command: " + name
def main():
print(log_command("rotate-90"))
@@ -0,0 +1,6 @@
def set_limits(max_speed: Int, max_accel: Int):
print("speed:", max_speed, "accel:", max_accel)
def main():
set_limits(5, 2)
@@ -0,0 +1,6 @@
def spin_up(rpm: Int, ramp_ms: Int) -> Int:
return rpm + ramp_ms
def main():
print("total:", spin_up(900))
@@ -0,0 +1,8 @@
def run_diagnostic(name: String, *, verbose: Bool) -> String:
if verbose:
return name + " [verbose]"
return name
def main():
print(run_diagnostic("imu", True))
@@ -0,0 +1,9 @@
def total(readings: Int) -> Int:
var s = 0
for r in readings:
s += r
return s
def main():
print("sum:", total(3, 4, 5))
@@ -0,0 +1,7 @@
def run_self_test():
# TODO: implement the real self-test later; this is just a stub
def main():
run_self_test()
print("self-test stub ran")
@@ -0,0 +1,6 @@
def footprint(side: Int) -> Int:
return side * side
def main():
print(footprint(4), footprint(2, 3))
@@ -0,0 +1,8 @@
def read_sensor(id: Int) raises -> Int:
if id < 0:
raise Error("bad sensor id")
return id * 10
def main():
print("reading:", read_sensor(2))
@@ -0,0 +1,4 @@
def main():
tick_count = 0
tick_count += 1
print("Ticks processed:", tick_count)
Loaded 100 of 1567 files, more files were not shown because too many files have changed in this diff. Show more