1. Install the mod

1. Download taleos-0.1.0.jar from CurseForge.
2. Copy it into the Hytale server's Server/mods/ directory.
3. Restart the server. TaleOS requires Java 25 and is built against Hytale server 0.6.2.
4. Join with the vanilla client. No client installation is required.

2. Craft and place a Computer

At a Workbench → Survival, combine 4 copper bars + 4 Deadwood planks. Place the Computer and press F to open its terminal.

After booting, you should see TaleOS v0.1 (TaleOS) and the tale> prompt.

3. Try the shell

id
help
echo Hello, Hytale!
lua

In the Lua REPL, enter:

print("Hello from Lua!")
tale.getComputerID()
exit

The REPL first tries to evaluate your input as an expression; if that fails, it runs it as a statement. It prints returned non-nil values. Type exit to return to the shell.

4. Create a program

Run edit hello.lua. Enter this program, save it, and use Save and run (or save and type hello):

local id = os.getComputerID()
print("Hello from computer #" .. id)

for i = 1, 3 do
  print("Count: " .. i)
  os.sleep(1)
end

The editor offers save, save-and-run, exit and Tab completion. The terminal also supports completion; the running-program Stop button terminates a program without killing the shell.

5. Run automatically at boot

Create startup.lua in the computer's root directory. TaleOS executes it before the shell, both after a server restart and after reboot. Errors are printed and the shell still starts.

-- startup.lua
print("Computer #" .. os.getComputerID() .. " is ready")

Tools and weapons

TaleOS does not add special tools. Use ordinary Hytale pickaxes, shovels, weapons and other registered tools in Turtle upgrade slots. A tool appropriate for the target block is required for digging. Tools and weapons do not lose durability when used by a Turtle.

Stacking and identity

Computers, Turtles, Pocket Computers and PenDrives have persistent identity and do not stack. Monitors, USB drives, NAS units, Modems and Speakers can stack up to 25 before identity is attached. Breaking a Computer or Turtle creates an item labeled with its ID; placing it again preserves its files and state.

Using the terminal

Press F on a Computer or Turtle. Type at the prompt and press Enter. The output area keeps a scrollable transcript. Completion is available with Tab in the terminal and editor. Use Stop to terminate the currently running program; the shell itself remains available.

The native Lua terminal is a 51×19 character grid. It supports cursor positioning, scrolling, independent foreground/background colors per cell, blit, clipped windows and redirection to Monitors.

Persistent files

Each machine has a jailed filesystem with a 1 MiB quota. Computer files live in mods/TaleOS/computers/<id>/. The read-only rom/ mount contains TaleOS and built-in programs. PenDrives have independent 1 MiB quotas.

Shell paths are relative to the current directory. Absolute paths start with /. Both . and .. are normalized, and attempts to escape the computer's filesystem are rejected.

Identity when broken

Breaking a Computer or Turtle produces an item labeled Computer #ID or Turtle #ID. Its ID, files, inventory and equipped upgrades are retained when placed again. These items do not stack, preventing two placed machines from sharing one live disk.

Lua sandbox and budgets

TaleOS uses LuaJ with a per-tick instruction budget (200,000 bytecodes by default). Infinite loops, including loops hidden in pcall, xpcall or child coroutines, are killed without stopping the server.

Scripts cannot access Java, host files, host I/O or native process execution. luajava, io, debug, package, require, dofile and loadfile are unavailable. The standard os table is replaced by a safe TaleOS version.

Loaded chunks

World reads and Turtle actions require loaded chunks. With no players nearby, a chunk may unload and block reads return no block. Server owners can use vanilla keep-loaded settings for automation areas; see Administration.

Arguments separated by spaces are passed to programs as strings. Your own name.lua in the current directory can be run with name. Built-in ROM programs take precedence when names collide.

Turtle-only commands

Examples

mkdir programs
cd programs
edit counter.lua
counter
cd ..
ls /
cat /startup.lua

Output and arguments

print(...) converts values to text, separates them with tabs and writes a newline. A program invoked as demo one 2 receives "one" and "2" through ....

local name, countText = ...
countText = tonumber(countText) or 1
print("Hello, " .. (name or "world"))
for i = 1, countText do
  print("Iteration " .. i)
end

Errors and action results

Filesystem errors raise Lua errors and can be caught with pcall. Turtle actions usually return true or false, reason. Peripheral method errors may also raise Lua errors; handle them when hardware may be absent.

local ok, reason = turtle and turtle.forward()
if turtle and not ok then
  print("Blocked: " .. tostring(reason))
end

local wrote, err = pcall(fs.write, "status.txt", "ready")
if not wrote then print(err) end

Waiting for events

Use os.pullEvent() to wait for any event or os.pullEvent("timer") to accept only one kind. os.pullEventRaw does not filter. See the event reference for exact fields.

local timer = os.startTimer(2)
while true do
  local event, id = os.pullEvent()
  if event == "timer" and id == timer then
    print("Two seconds elapsed")
    break
  end
end

Two tasks at once

parallel.waitForAny returns when one function finishes; waitForAll waits for every function. Tasks cooperate through events and yields rather than preemptive threads.

local function ticker()
  while true do
    os.sleep(1)
    print("tick")
  end
end

local function listener()
  local event, side = os.pullEvent("peripheral")
  print("Attached on " .. side)
end

parallel.waitForAny(ticker, listener)

Startup and persistence

Save durable state with fs.write or fs.append; do not rely only on Lua variables. Put unattended behavior in startup.lua. A startup program that loops forever still receives events and can be stopped from the terminal.

Paths are strings. The shell-wrapped API resolves relative paths against the current directory; / selects the root. Missing files generally return nil on reads, while invalid writes, missing directories, read-only mounts and quota errors raise Lua errors prefixed with fs:.

Example: append a log

fs.mkdir("logs")
fs.append("logs/activity.txt", os.date() .. " started\n")

if fs.exists("logs/activity.txt") then
  print(fs.read("logs/activity.txt"))
  print(fs.getSize("logs/activity.txt") .. " bytes")
end

print(fs.getFreeSpace("logs") .. " bytes free")

Mounted media

USB media appear as usb, usb2, etc. NAS media appear as nas/<PenDriveID>. Use fs.getCapacity("nas/22") or fs.getFreeSpace("usb") to query a specific medium. Removing a PenDrive removes its mount and subsequent accesses fail rather than reading stale data.

One-shot and repeating timers

local id = os.startTimer(5)
print("Timer #" .. id)

local event, fired = os.pullEvent("timer")
if fired == id then print("Five seconds elapsed") end

os.queueEvent("my_event", 42, { ready = true })
local name, value, data = os.pullEvent("my_event")
print(name, value, data.ready)

The first return value is always the event name. Subsequent values depend on the event. Events are delivered in FIFO order and the queue is bounded to 256 entries.

Reading a modem message

local event, side, channel, replyTo, payload, distance =
  os.pullEvent("modem_message")

print("Received on " .. side .. ", channel " .. channel)
print("Reply channel: " .. replyTo)
print("Distance: " .. distance)

Coordinates are one-based: 1,1 is the upper-left cell. Terminal color arguments accept either a color name or a single power-of-two value from colors. print writes to the current redirect target.

Using blit

Each character in the color strings is a hexadecimal digit representing a palette index: 0 is black, f is white, 5 is lime. All three strings must have the same length.

term.clear()
term.setCursorPos(1, 1)
term.blit("TaleOS", "555555", "000000")
term.setCursorPos(1, 3)
term.setTextColor(colors.lime)
term.setBackgroundColor(colors.black)
term.write("Colored terminal text")

Always restore redirects

local previous = term.redirect(term.native())
-- Work with the selected target here.
term.redirect(previous)

colors and colours are the same table. Each named value is a power of two. Terminal functions accept these values; Monitor pixel functions use the equivalent names.

A window has its own cursor, colors, visibility and dimensions. Drawing is clipped to the window and does not move or scroll its parent's cursor.

Windows also implement the terminal methods: write, blit, clear, clearLine, scroll, getSize, setCursorPos, getCursorPos, setCursorBlink, getCursorBlink, setTextColor, getTextColor, setBackgroundColor, getBackgroundColor and isColor.

Two independent panels

term.clear()
local left = window.create(term.current(), 1, 1, 24, 8, true)
local right = window.create(term.current(), 27, 1, 24, 8, true)

left.setTextColor(colors.lime)
left.write("Status: online")
right.setTextColor(colors.yellow)
right.write("Storage: 80%")

local previous = term.redirect(left)
print("This appears in the left panel")
term.redirect(previous)

Functions execute cooperatively as coroutines. Long-running tasks should wait for events, timers or world calls. An error in one task is propagated to the caller.

local function listen()
  while true do
    local event, side = os.pullEvent("peripheral")
    print("Peripheral attached: " .. side)
  end
end

local function heartbeat()
  while true do
    print("alive")
    os.sleep(5)
  end
end

parallel.waitForAll(listen, heartbeat)

print("Current directory: /" .. shell.dir())
print(shell.resolve("../shared/data.txt"))
print(shell.resolve("/nas/22/program.lua"))

Relative coordinates are offsets from the machine: 0,-1,0 is the block immediately below. World calls run safely on the server tick thread and are limited to 32 world calls per machine per tick.

Inspect the ground

local id = tale.getBlock(0, -1, 0)
if id then
  print("Block below: " .. id)
else
  print("Air or unloaded chunk")
end

if tale.detect(1, 0, 0) then
  tale.chat("There is a block beside computer #" .. os.getComputerID())
end

The API exists only when HTTP is enabled in mods/TaleOS/config.json. TaleOS 0.1.0 supports text GET requests, not POST, WebSockets, proxies or Git cloning.

Download and save a Lua file

local response, err = http.get(
  "https://raw.githubusercontent.com/user/repo/main/program.lua")
if not response then error(err) end

local code, reason = response.getResponseCode()
if code < 200 or code >= 300 then
  response.close()
  error("HTTP " .. code .. " " .. reason)
end

local body = response.readAll()
response.close()
fs.write("program.lua", body)
print("Saved " .. #body .. " bytes")

Or use the shell: wget https://raw.githubusercontent.com/user/repo/main/program.lua program.lua, then run program.

Place a Monitor beside a Computer or Turtle. Monitors are output devices: they do not open an interface with F. Use tale.monitor(), peripheral.wrap("side") or peripheral.find("monitor") from Lua.

Dimensions and multi-block displays

Each Monitor provides 40×24 pixels and a 10×4 character terminal. Compatible Monitors with the same facing join into rectangles up to 8×8 blocks: 320×192 pixels and 80×32 terminal cells. Every block renders its own crop of the shared canvas.

Resizing preserves compatible content. Splitting a structure creates independent canvases and queues monitor_resize for affected attachments.

Getting a Monitor

local mon = tale.monitor() -- search all six neighbors
if not mon then error("No adjacent Monitor") end

-- Or by peripheral side:
local bySide = peripheral.wrap("right")
-- Or all attached Monitors:
local first, second = peripheral.find("monitor")

Pixel methods

Pixel coordinates are one-based. Pixel colors are palette names such as "black", "lime" or "white". The built-in microfont uses 3×5 glyphs.

Terminal methods

Monitors also support write(text), blit, clearLine, scroll, setCursorPos, getCursorPos, setCursorBlink, getCursorBlink, setTextColor, getTextColor, setBackgroundColor, getBackgroundColor and isColor. Their cursor and color operations use character cells, not pixels.

local mon = tale.monitor()
mon.clear("navy")
mon.fill(5, 5, 20, 3, "blue")
mon.write(5, 10, "TALEOS", "lime")

-- Use it as a normal terminal:
local previous = term.redirect(mon)
term.setTextColor(colors.white)
print("Hello on the Monitor")
term.redirect(previous)

Built-in clock

Place a Monitor adjacent to a Computer and run reloj. The program clears the canvas once per second, redraws all eight HH:MM:SS characters and sleeps for 20 ticks. Stop it from the terminal.

Inventory and upgrades

Press F on a Turtle to combine its terminal, 4×4 inventory, your inventory and two upgrade slots. Lua slots are numbered 1–16, left-to-right and top-to-bottom. The selected slot is highlighted and defaults to slot 1.

The left and right upgrade slots accept ordinary tools and weapons, TaleOS_Modem, TaleOS_Speaker and TaleOS_Crafting_Upgrade. Equipped hardware appears on the 3D chassis and tools swing when used. Tools and weapons do not consume durability.

Equipping from Lua or the shell

-- Select a slot containing a pickaxe, then:
equip left

-- Select an empty slot to retrieve it:
unequip left

turtle.select(1)
local ok, reason = turtle.equipLeft()
if not ok then print(reason) end

turtle.select(2)
turtle.equipRight()

Action results

Most physical actions return true on success or false, reason on failure. Always check the result in unattended programs. Movement and turning are animated, and a Turtle retains its running program, ID, files, inventory and upgrades while moving.

for i = 1, 10 do
  while turtle.detect() do
    local ok, reason = turtle.dig("right")
    if not ok then error(reason) end
    tale.sleep(2)
  end
  local moved, reason = turtle.forward()
  if not moved then error(reason) end
end

Mining and combat

turtle.dig requires a suitable tool with sufficient gathering quality. Without a side argument it tries equipped tool slots; pass "left" or "right" to choose explicitly. Drops enter the Turtle inventory when possible.

turtle.attack uses an equipped weapon against a damageable target in the selected direction. It returns false when there is no valid target or a solid block obstructs the attack.

Crafting

Equip a Crafting Upgrade and arrange ingredients in the 16 inventory slots. turtle.craft([limit]) searches supported ordinary tier-0 Crafting recipes and creates up to limit crafts (default 64). Input and output stacks, including relevant metadata, are planned before changes are committed.

Useful built-ins

• go forward 10 — move ten blocks.
• turn right 2 — turn around.
• tunnel 5 — dig five sections of a 3×3 tunnel.
• excavate 8 — dig eight sections of a 1×3 face.

This table exists only on Turtles. Unless noted otherwise, action functions return true or false, reason. Direction suffixes Up and Down select those faces; unsuffixed world actions use the front.

Movement and turning

Detection, inspection and comparison

local ok, info = turtle.inspectDown()
if ok then print("Standing on " .. info.name) end
if turtle.compareDown() then print("Selected item matches the ground") end

Inventory

Upgrades and fuel

Digging, attacking, crafting and placing

World item transfer

Small builder example

for i = 1, 8 do
  if turtle.getItemCount() == 0 then
    error("Selected slot is empty")
  end
  local ok, reason = turtle.placeDown()
  if not ok then error(reason) end
  ok, reason = turtle.forward()
  if not ok then error(reason) end
end

PenDrives

Each PenDrive has a persistent numeric ID, an optional label and an independent 1 MiB filesystem. Its ID appears as PenDrive #ID in storage interfaces. PenDrives do not stack and cannot be inserted in two places at once.

USB drives

Insert one PenDrive into a USB Drive adjacent to a Computer or Turtle. It mounts at usb, usb2, etc., depending on how many drives are attached. The usb_drive peripheral can inspect, rename, locate and eject media.

local drive = peripheral.find("usb_drive")
if drive and drive.isPenDrivePresent() then
  print("Drive #" .. drive.getPenDriveID())
  print("Mounted at " .. drive.getMountPath())
  print(fs.read(drive.getMountPath() .. "/readme.txt"))
end

usb_drive methods

Stackable NAS units

Each NAS holds 8 PenDrives. Face-connected NAS units form one storage component. Every running Computer, Turtle or Pocket Computer within a spherical 16-block range of that component receives mounts at nas/<PenDriveID>.

All connected machines see the same live files: a program saved to nas/22/startup.lua can be read or executed by another machine with access to PenDrive 22. Removing media or moving out of range unmounts it; stale mounts are removed automatically.

ls nas
cd 22          -- shortcut for cd nas/22
ls
cat LEEME_NAS.txt
cd /
cat nas/22/shared-program.lua

Run a mounted program from the shell by using a path that resolves to its Lua file, or load its source explicitly in your own program. For portable startup logic, copy the desired program to the machine's own startup.lua.

Media events

usb and usb_eject fire with a side name when media mounts or unmounts. NAS media use nas as the event side. See Events.

Craft with one Computer and two copper bars. Use the Pocket Computer item to open the mobile terminal. It has the same shell, Lua APIs, editor, filesystem and 1 MiB local quota as other machines.

Persistent identity

A Pocket Computer keeps its ID and files while carried. Duplicate stacks cannot start multiple sessions on the same disk, protecting the filesystem from concurrent writers.

When execution suspends

Execution and NAS access suspend when the item is dropped, its holder disconnects or changes worlds. Returning to a valid held state resumes the mobile session with the same persistent identity.

NAS on the move

Nearby connected NAS units are discovered around the player using the same 16-block range. Mounts follow the player and are removed when media leaves range or the Pocket Computer suspends.

Peripheral names are usually side strings: left, right, top, bottom, front, back. Turtle upgrades use their corresponding side. Coordinate aliases use @dx,dy,dz for directly addressed neighbors.

Discovery example

for _, name in ipairs(peripheral.getNames()) do
  print(name .. " is " .. tostring(peripheral.getType(name)))
  for _, method in ipairs(peripheral.getMethods(name)) do
    print("  " .. method)
  end
end

local speaker = peripheral.find("speaker")
if speaker then speaker.playSound("TaleOS_Boot_Beep") end

Listen for peripheral and peripheral_detach to react to hardware changes.

Wrap a supported container as an inventory peripheral. Slots are one-based. Turtles can additionally move items with suck and drop.

local chest = peripheral.find("inventory")
if chest then
  print("Slots: " .. chest.size())
  for slot, stack in pairs(chest.list()) do
    print(slot, stack.name, stack.count)
  end
end

Place a Modem adjacent to a Computer or equip it on a Turtle. Messages reach loaded receivers in the same world within the configured range (64 blocks by default). Payloads are deep-copied and bounded; each receiver is limited to 32 messages per tick by default.

modem methods

rednet functions

Rednet manages channels and protocols for you. It opens your computer ID and rednet.CHANNEL_BROADCAST (65535) when rednet.open succeeds.

Two-computer chat

-- Receiver:
rednet.open("right")
local sender, message = rednet.receive("demo", 10)
if sender then print(sender .. ": " .. tostring(message)) end

-- Sender (replace 8 with the receiver's ID):
rednet.open("left")
rednet.send(8, "Hello!", "demo")

GPS uses channel gps.CHANNEL = 65534. A locating machine needs a wireless Modem and responses from at least four non-coplanar references with consistent distances.

Set up a GPS network

1. Place four Computers with wireless Modems at known, non-coplanar positions.
2. Run gps host <x> <y> <z> on each, using its actual coordinates.
3. Attach a Modem to the locating machine and run gps locate.

local x, y, z = gps.locate(3)
if x then
  print(string.format("Position: %.2f %.2f %.2f", x, y, z))
else
  print("GPS failed: " .. tostring(y))
end

Place a Speaker beside a Computer or equip it on a Turtle. TaleOS plays existing registered SoundEvents; arbitrary microphone input, note synthesis and streaming audio are not included.

Sound names may contain letters, digits, underscore, dot, slash and hyphen, up to 256 characters. Unknown SoundEvents return false. Playback is limited to one sound per equipped Speaker per tick.

local speaker = peripheral.find("speaker")
if not speaker then error("No Speaker attached") end

local ok, reason = speaker.playSound("TaleOS_Boot_Beep", 1, 1)
if not ok then print(reason) end

TaleOS creates mods/TaleOS/config.json relative to the server working directory. Edit it while the server is stopped, then restart. Keep a backup before making changes.

Complete default configuration

{
  "language": "en",
  "http": {
    "enabled": true,
    "max_requests": 16,
    "timeout_seconds": 30,
    "max_redirects": 16,
    "bandwidth": {
      "global_download": 33554432
    },
    "rules": [
      { "host": "$private", "action": "deny" },
      { "host": "*", "action": "allow", "max_download": 16777216 }
    ]
  },
  "modem": {
    "range": 64,
    "max_messages_per_tick": 32
  }
}

English or Spanish

Set "language": "en" (default) or "language": "es". This translates TaleOS interfaces, commands, Turtle messages, peripherals, errors and admin output. Lua API names and text produced by user programs do not change.

HTTP settings

Host rules

Rules support domains, IPs, wildcards such as *.example.com, CIDR ranges and the special $private group. Every DNS result and redirect destination is checked again. max_download limits bytes for a matching rule; 16777216 is 16 MiB.

"rules": [
  { "host": "$private", "action": "deny" },
  { "host": "raw.githubusercontent.com", "action": "allow", "max_download": 16777216 },
  { "host": "*.example.com", "action": "allow", "max_download": 1048576 },
  { "host": "*", "action": "deny" }
]

Wireless settings

modem.range is the same-world wireless radius in blocks, and modem.max_messages_per_tick limits delivery work. Both accept values from 1 to 256. Invalid modem settings use safe defaults (64 and 32).

Persistent server data

• mods/TaleOS/computers/ — machine files.
• mods/TaleOS/pendrives/ — removable media.
• mods/TaleOS/logs/ — per-computer transcripts.
• mods/TaleOS/ids.json and turtles.json — identity and Turtle state.

The /taleos command

/taleos <world> <x> <y> <z> <shell line…>

Boot the computer at that block if needed and queue one shell line. This is useful for automated tests and server administration. From the server console, omit the slash as required by Hytale's command parser.

taleos creative_test 191 123 -64 id
taleos creative_test 191 123 -64 ls nas
taleos creative_test 199 123 -65 __turtle id

Administrative diagnostics available at the same coordinates include __probe for chunk/block diagnostics, __blockid for block IDs, __stop to request program termination and __nasdebug to log NAS media locations. Turtle commands can be prefixed with __turtle .

Computer logs

Every machine writes a timestamped transcript to mods/TaleOS/logs/computer-<id>.log. It includes boots, submitted commands, shell output and program errors. Use these logs instead of relying on screenshots when diagnosing automation.

Keep automation loaded

Machines need loaded chunks for world reads, wireless delivery and physical actions. Hytale's vanilla keep-loaded command can maintain an automation area:

/world settings keeploaded set <minX> <minZ> <maxX> <maxZ> --world=<world>

Backups and updates

Back up mods/TaleOS/ together with the world before updating or migrating a server. Do not delete identity files while keeping machine disks: IDs bind placed blocks, portable items, PenDrives and their data.

Built-in smoke test

Starting the JVM with -Dtaleos.selftest=true runs a startup smoke test: boot to the TaleOS prompt, submit an ID command and verify that an infinite loop is killed by its instruction budget while the server remains alive.

Platform

• Early Access, built for Hytale server 0.6.2 and Java 25.
• Server-side installation; vanilla clients receive the assets.
• English and Spanish interfaces; English by default.
• 1 MiB quota per machine and per PenDrive.
• 51×19 native terminal; 16-color palette.

Relationship to other computer mods

TaleOS is a clean-room implementation inspired by the programmability of computer mods. Familiar names such as fs, term, peripheral, rednet and turtle do not imply complete API or program compatibility. Check signatures and return values in this wiki when porting a program.

Not implemented in 0.1.0

• Floppy disks and disk drives—TaleOS uses PenDrives, USB readers and NAS instead.
• Redstone APIs, command computers, printers, wired networks and energy/fluid peripherals.
• Multishell/tabbed program management, mouse input, monitor touch and paint/image file formats.
• HTTP POST, WebSockets, proxies, arbitrary binary downloads and Git cloning.
• Speaker audio streaming or arbitrary user audio; only registered SoundEvents.
• Lua require, package, host io, Java access and native file access.
• Automatic chunk loading by computers themselves.

Operational limits

Lua instruction budgets kill runaway code, world calls are limited per tick, HTTP is asynchronous and validated, event queues are bounded, and network messages are size/rate limited. These protections reduce server risk but do not replace sensible permissions, backups and resource monitoring.

1. Monitor status board

Save as status.lua with a Monitor adjacent to the Computer:

local mon = tale.monitor()
if not mon then error("Place a Monitor next to this Computer") end

while true do
  local width = mon.getSize()
  local text = "ONLINE #" .. os.getComputerID()
  mon.clear("navy")
  mon.fill(1, 1, width, 1, "blue")
  mon.write(2, 2, text, "lime")
  mon.write(2, 10, os.date("%H:%M:%S"), "white")
  tale.sleep(20)
end

2. Peripheral event logger

fs.mkdir("logs")
print("Watching peripherals…")
while true do
  local event, name = os.pullEvent()
  if event == "peripheral" or event == "peripheral_detach" then
    local line = os.date() .. " " .. event .. " " .. name .. "\n"
    fs.append("logs/peripherals.txt", line)
    print(line)
  end
end

3. Safe dig-and-place routine

For a Turtle with a suitable tool in the right upgrade slot and blocks in slot 1:

local function check(ok, reason)
  if not ok then error(reason or "Action failed") end
end

turtle.select(1)
for step = 1, 10 do
  turtle.turnRight()
  if turtle.detectDown() then
    check(turtle.digDown("right"))
    tale.sleep(2)
  end
  check(turtle.placeUp())
  turtle.turnLeft()
  check(turtle.forward())
  print("Step " .. step .. "/10")
end

4. Networked doorbell

-- Computer beside a Speaker:
rednet.open("right")
local speaker = peripheral.find("speaker")
while true do
  local sender, message = rednet.receive("doorbell")
  if message == "ring" then
    print("Bell from #" .. sender)
    if speaker then speaker.playSound("TaleOS_Boot_Beep") end
  end
end

-- Another Computer:
rednet.open("left")
rednet.broadcast("ring", "doorbell")

5. Shared NAS configuration

local path = "nas/22/settings.txt"
if not fs.exists(path) then
  fs.write(path, "motd=Hello from shared storage")
end

local settings = fs.read(path)
print(settings)

Adapt the PenDrive ID to one shown by ls nas. Any machine in range can read the same file.