Al-Jazarī, Automata, and Sequenced Mechanical Action: Clocks, Machines, and Embodied Algorithmic Reasoning

Last Updated June 23, 2026

Al-Jazarī, Automata, and Sequenced Mechanical Action examines one of the most important premodern examples of procedure embodied in machines. Al-Jazarī’s Book of Knowledge of Ingenious Mechanical Devices, completed in the early thirteenth century, describes clocks, vessels, fountains, water-raising machines, automata, and control mechanisms with unusual attention to construction, sequencing, timing, and operation. For the history of algorithmic reasoning, the significance is not that these devices were modern computers. It is that they organized material action into designed sequences.

A clock can mark time because its internal states change in a controlled order. A water-raising machine can repeat useful work because motion is transmitted through a structured mechanism. A musical automaton can perform a patterned sequence because timed physical components activate in order. A vessel can behave unexpectedly because hidden channels and thresholds produce conditional action.

This article treats al-Jazarī’s automata as sequenced mechanical action. The phrase is intentionally careful. These mechanisms are not software, robotics, or AI in the modern sense. They are physical systems in which geometry, flow, pressure, weight, timing, gearing, cams, levers, and vessels are arranged so that action unfolds according to a repeatable procedure.

This article introduces al-Jazarī, the Book of Knowledge of Ingenious Mechanical Devices, automata, water clocks, elephant clock traditions, castle clock logic, water-raising machines, cams, gears, levers, floats, vessels, fountains, control mechanisms, timing sequences, documentation, reproducibility, mechanical design, Islamic-world engineering, and embodied algorithmic reasoning. It argues that al-Jazarī belongs in the history of algorithms because his devices reveal procedure as material organization: parts arranged so that action follows a structured sequence.

Why Al-Jazarī Matters

Al-Jazarī matters because his devices show mechanical design as a disciplined procedure. They combine imagination with engineering specificity: a device is described not only by what it displays, but by how it is assembled, activated, sequenced, and maintained. The result is a technical culture in which mechanical behavior becomes reproducible knowledge.

For algorithmic history, al-Jazarī is important because his machines contain recognizable structures of procedural reasoning. They include input, state, timing, thresholds, transitions, repetition, output, and documentation. This does not make them digital algorithms. It does make them powerful examples of designed sequences that transform physical conditions into observable action.

Al-Jazarī matters because he helps show that procedure can be built into machines before it is written as code.

Back to top ↑

Sequenced Mechanical Action

Sequenced mechanical action means that a device performs actions in a designed order. The order may be controlled by water level, weight, flow, pressure, gear movement, cam shape, float position, or timed release. The device moves through states, and each state prepares or triggers the next.

This is different from a static tool. A hammer acts when a person uses it. A sequenced automaton acts through internal arrangement once the initial condition is set. It may ring, pour, strike, rotate, lift, display, or reset because the device is organized as a sequence of material transformations.

Sequenced mechanical action is procedure made visible in time.

Back to top ↑

The Book of Knowledge of Ingenious Mechanical Devices

Al-Jazarī’s major work is widely known through the English title The Book of Knowledge of Ingenious Mechanical Devices. It describes numerous devices, commonly grouped into categories such as clocks, vessels, fountains, water-raising machines, and other mechanisms. Its importance lies not only in the devices themselves, but in the combination of image, description, construction detail, and operational logic.

The book demonstrates a technical imagination that joins art, mechanics, courtly display, practical engineering, and procedural explanation. It is both visual and operational. The diagrams are not merely decorative; they help communicate how parts relate and how action unfolds.

The book is a technical document of action, not only a gallery of mechanical wonders.

Back to top ↑

Automata as Material Procedure

An automaton is a device that produces movement or action through its internal structure. In al-Jazarī’s work, automata may appear as figures, animals, servants, musicians, or clock elements, but the core engineering question is procedural: what sequence of physical changes makes the action occur?

Automata are material procedures because they encode behavior in parts. A figure moves because a linkage moves. A sound occurs because a timed trigger releases a mechanism. A vessel pours because a hidden passage permits flow. The procedure is not written as software. It is embedded in arrangement.

Automata show how behavior can be delegated to mechanical arrangement.

Back to top ↑

Clocks, Time, and State Change

Clocks are central to al-Jazarī’s mechanical imagination because they turn time into state change. A water clock, for example, can use controlled flow to mark intervals. As water moves, a float drops or rises, a mechanism turns, a display changes, or a figure performs an action.

This makes clocks especially important for algorithmic reasoning. A clock is not simply a measuring instrument. It is a system that converts continuous physical change into discrete events: a mark, a sound, a figure, a display, a transition. Timed action becomes a sequence of observable states.

A clock is a machine for making time procedural.

Back to top ↑

The Elephant Clock and Layered Sequence

The elephant clock is one of al-Jazarī’s most famous devices. It is often remembered for its visual richness, but it is also important as a layered sequence of mechanical actions. The clock combines water timing, a sinking or moving element, release mechanisms, moving figures, sound, and display. The viewer sees a theatrical event; the engineer sees a controlled sequence of states.

Its visual program has often attracted attention because it integrates motifs from multiple cultures. For this article, the central point is procedural. The elephant clock demonstrates how time, motion, display, and symbolic staging can be coordinated through mechanical design.

The elephant clock is a system of timed states, not only a spectacular image.

Back to top ↑

Cams, Levers, and Mechanical Control

Cams and levers are crucial because they convert one kind of motion into another. A rotating part can lift, release, strike, open, close, or push. A lever can magnify or redirect force. A cam profile can determine when an action occurs during a cycle.

This is mechanical control. The shape of the part encodes a timing relation. The position of the lever encodes a transformation. Action is not only caused; it is scheduled and shaped by design.

Mechanical control shows that procedure can be encoded in shape, position, and motion.

Back to top ↑

Water-Raising Machines and Repeated Work

Al-Jazarī’s work also includes water-raising machines. These devices matter because they connect automation with useful repetitive labor. A water-raising mechanism does not merely display motion; it converts energy into repeated work. It lifts, transfers, or channels water through a sequence that can repeat.

This is important for algorithmic reasoning because repeated work is one of the core ideas behind procedure. A mechanism can perform the same operation again and again under appropriate conditions. In modern computing, loops repeat instructions. In mechanical systems, rotation, cycling, and reset can repeat physical operations.

Water-raising machines show procedure as repeated physical work.

Back to top ↑

Floats, Vessels, and Thresholds

Floats and vessels are central to timed and conditional mechanical action. A vessel stores a quantity. A float responds to level. A threshold defines when a transition occurs. These elements allow devices to convert gradual change into discrete events.

A float does not “decide” in a mental sense, but it can create different outcomes under different conditions. If the water level is below a point, nothing happens. If it reaches the point, a release occurs. This is a physical if-condition.

Floats and vessels transform quantity into sequence.

Back to top ↑

Musical Automata and Patterned Performance

Musical automata are especially relevant to algorithmic reasoning because performance requires sequence. A sound must occur in an order, at an interval, with a relation to other sounds. Even a simple mechanical musical device raises questions about timing, repetition, variation, and activation.

Al-Jazarī’s automata are sometimes discussed in connection with programmable or adjustable performance. This language should be used carefully, because modern programmability is different. Still, the deeper point is valid: mechanical design can encode patterned performance. It can make an action repeat, vary, or occur at a scheduled time.

Mechanical performance shows how timing and action can be coordinated before electronic control.

Back to top ↑

Documentation, Diagrams, and Reproducibility

Al-Jazarī is especially valuable because his work documents mechanisms. A machine described only as a marvel may inspire awe, but a machine described through parts, diagrams, and operation becomes teachable. Documentation turns mechanism into knowledge.

This is why his work belongs in a series on algorithms and computational reasoning. The book makes procedure explicit enough to study. It identifies components, explains sequences, records operational logic, and invites reconstruction or analysis. In modern terms, it is not code, but it is technical specification.

Documentation makes mechanical action reproducible across time, place, and reader.

Back to top ↑

Implementation, Debugging, and Material Constraint

A mechanical procedure works only if implementation matches design. A channel must be the right size. A seal must hold. A float must move freely. A cam must strike at the right time. A reservoir must fill at the intended rate. A device may fail because of leakage, friction, imbalance, wear, or misalignment.

This makes mechanical engineering a form of debugging. The intended sequence must be compared with observed behavior. If the output is wrong, the builder asks where the procedure failed: input, state, trigger, transition, output, reset, or material constraint.

Mechanical procedure is only as reliable as its implementation.

Back to top ↑

From Automata to Modern Computation

Al-Jazarī’s devices are not modern computers, but they help explain why automata matter to the history of computation. Automata make behavior formal enough to repeat. They show that actions can be triggered, sequenced, constrained, and displayed without direct human intervention at every step.

The connection to modern computation is conceptual rather than direct. Modern computing uses symbolic instructions, digital states, programmable memory, and electronic or logical circuits. Al-Jazarī’s automata use water, pressure, geometry, and mechanical transmission. But both invite the same kind of question: how can a designed system produce reliable behavior through internal structure?

The bridge is not identity. The bridge is the history of structured behavior.

Back to top ↑

Origin Stories and Careful Interpretation

Al-Jazarī should not be turned into a simple origin story for robots, computers, or AI. Mechanical devices existed in many earlier traditions, including Hellenistic, Byzantine, Persian, Indian, Chinese, and Islamic-world contexts. Al-Jazarī’s importance lies in his synthesis, documentation, mechanical creativity, and attention to reproducible design.

Careful interpretation also avoids minimizing the devices as toys. Courtly, spectacular, decorative, or playful devices can still be serious engineering artifacts. An automaton that delights an audience can also demonstrate control, timing, pressure, mechanical transmission, and procedural imagination.

A careful history treats al-Jazarī as a major engineer of sequenced mechanical action, not a mascot for modern technology.

Back to top ↑

Back to top ↑

Mathematics, Computation, and Modeling

A sequenced mechanical device can be modeled as a state transition system:

A timed event can be modeled as:

A repeated mechanical cycle can be represented as:

A sequenced automaton can be summarized as:

These formulas use modern notation to make the computational structure visible. They are interpretive models, not claims that al-Jazarī used this symbolic notation.

Back to top ↑

Python Workflow: Sequenced Mechanical Action Map

The Python workflow below creates a dependency-light interpretive map of al-Jazarī, automata, and sequenced mechanical action. It scores themes by sequence structure, timing control, mechanical embodiment, conditional action, repeatability, documentation quality, historical significance, ethical caution, and modern resonance, then writes reproducible CSV and JSON outputs.

# al_jazari_automata_sequenced_action_map.py
# Dependency-light workflow for mapping automata as sequenced mechanical action.

from __future__ import annotations

from dataclasses import asdict, dataclass
from pathlib import Path
from statistics import mean
import csv
import json
from datetime import datetime, timezone

ARTICLE_ROOT = Path(__file__).resolve().parents[1]
TABLES = ARTICLE_ROOT / "outputs" / "tables"
JSON_DIR = ARTICLE_ROOT / "outputs" / "json"


@dataclass(frozen=True)
class SequencedActionConfig:
    article: str = "al_jazari_automata_and_sequenced_mechanical_action"
    core_threshold: float = 0.80
    high_sequence_threshold: float = 0.86


def timestamp_utc() -> str:
    return datetime.now(timezone.utc).isoformat()


def write_csv(path: Path, rows: list[dict[str, object]]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    if not rows:
        path.write_text("", encoding="utf-8")
        return
    fieldnames = sorted({key for row in rows for key in row.keys()})
    with path.open("w", newline="", encoding="utf-8") as handle:
        writer = csv.DictWriter(handle, fieldnames=fieldnames, extrasaction="ignore")
        writer.writeheader()
        writer.writerows(rows)


def write_json(path: Path, payload: object) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(json.dumps(payload, indent=2, sort_keys=True), encoding="utf-8")


def sequenced_action_themes() -> list[dict[str, object]]:
    return [
        {"theme_id": "clocks_as_timed_state_change", "sequence_structure": 0.98, "timing_control": 0.98, "mechanical_embodiment": 0.94, "conditional_action": 0.90, "repeatability": 0.94, "documentation_quality": 0.92, "historical_significance": 0.96, "ethical_caution": 0.82, "modern_resonance": 0.96},
        {"theme_id": "elephant_clock_layered_sequence", "sequence_structure": 0.96, "timing_control": 0.94, "mechanical_embodiment": 0.96, "conditional_action": 0.92, "repeatability": 0.90, "documentation_quality": 0.92, "historical_significance": 0.96, "ethical_caution": 0.84, "modern_resonance": 0.94},
        {"theme_id": "cams_levers_control", "sequence_structure": 0.94, "timing_control": 0.92, "mechanical_embodiment": 0.98, "conditional_action": 0.92, "repeatability": 0.94, "documentation_quality": 0.88, "historical_significance": 0.94, "ethical_caution": 0.82, "modern_resonance": 0.96},
        {"theme_id": "water_raising_repeated_work", "sequence_structure": 0.92, "timing_control": 0.86, "mechanical_embodiment": 0.96, "conditional_action": 0.84, "repeatability": 0.98, "documentation_quality": 0.90, "historical_significance": 0.94, "ethical_caution": 0.84, "modern_resonance": 0.94},
        {"theme_id": "floats_vessels_thresholds", "sequence_structure": 0.92, "timing_control": 0.92, "mechanical_embodiment": 0.94, "conditional_action": 0.98, "repeatability": 0.90, "documentation_quality": 0.88, "historical_significance": 0.92, "ethical_caution": 0.82, "modern_resonance": 0.96},
        {"theme_id": "musical_automata_patterned_performance", "sequence_structure": 0.96, "timing_control": 0.96, "mechanical_embodiment": 0.94, "conditional_action": 0.88, "repeatability": 0.94, "documentation_quality": 0.88, "historical_significance": 0.92, "ethical_caution": 0.84, "modern_resonance": 0.96},
        {"theme_id": "diagrams_reproducibility_debugging", "sequence_structure": 0.88, "timing_control": 0.84, "mechanical_embodiment": 0.90, "conditional_action": 0.86, "repeatability": 0.90, "documentation_quality": 0.98, "historical_significance": 0.96, "ethical_caution": 0.86, "modern_resonance": 0.94},
    ]


def score_theme(row: dict[str, object], config: SequencedActionConfig) -> dict[str, object]:
    sequenced_action_score = mean([
        float(row["sequence_structure"]),
        float(row["timing_control"]),
        float(row["mechanical_embodiment"]),
        float(row["conditional_action"]),
        float(row["repeatability"]),
        float(row["documentation_quality"]),
        float(row["historical_significance"]),
        float(row["ethical_caution"]),
        float(row["modern_resonance"]),
    ])

    if sequenced_action_score >= config.core_threshold and float(row["sequence_structure"]) >= config.high_sequence_threshold:
        interpretive_status = "core_sequenced_mechanical_action_thread"
    elif sequenced_action_score >= config.core_threshold:
        interpretive_status = "major_sequenced_mechanical_action_thread"
    else:
        interpretive_status = "supporting_sequenced_mechanical_action_thread"

    return {
        "theme_id": row["theme_id"],
        "sequence_structure": round(float(row["sequence_structure"]), 6),
        "timing_control": round(float(row["timing_control"]), 6),
        "mechanical_embodiment": round(float(row["mechanical_embodiment"]), 6),
        "conditional_action": round(float(row["conditional_action"]), 6),
        "repeatability": round(float(row["repeatability"]), 6),
        "documentation_quality": round(float(row["documentation_quality"]), 6),
        "historical_significance": round(float(row["historical_significance"]), 6),
        "ethical_caution": round(float(row["ethical_caution"]), 6),
        "modern_resonance": round(float(row["modern_resonance"]), 6),
        "sequenced_action_score": round(sequenced_action_score, 6),
        "interpretive_status": interpretive_status,
    }


def interpretation_cautions() -> list[dict[str, str]]:
    return [
        {"caution": "do_not_call_al_jazari_devices_modern_robots", "meaning": "The devices are automata and mechanical sequences, not modern robotics or AI."},
        {"caution": "do_not_call_the_book_source_code", "meaning": "Diagrams and instructions are technical specifications, not software code."},
        {"caution": "do_not_ignore_courtly_display", "meaning": "Spectacle and entertainment can coexist with serious engineering."},
        {"caution": "do_not_project_general_purpose_programming_backward", "meaning": "Adjustable or sequenced behavior is not the same as modern programmability."},
        {"caution": "do_not_ignore_material_constraints", "meaning": "Flow, weight, leakage, timing, wear, and calibration shape actual operation."},
    ]


def main() -> None:
    config = SequencedActionConfig()
    themes = sequenced_action_themes()
    scored = [score_theme(row, config) for row in themes]
    cautions = interpretation_cautions()

    summary = {
        "article": config.article,
        "timestamp_utc": timestamp_utc(),
        "themes_reviewed": len(scored),
        "core_threads": sum(1 for row in scored if row["interpretive_status"] == "core_sequenced_mechanical_action_thread"),
        "major_threads": sum(1 for row in scored if row["interpretive_status"] == "major_sequenced_mechanical_action_thread"),
        "supporting_threads": sum(1 for row in scored if row["interpretive_status"] == "supporting_sequenced_mechanical_action_thread"),
        "mean_sequenced_action_score": round(mean(float(row["sequenced_action_score"]) for row in scored), 6),
        "cautions": len(cautions),
        "interpretation": "Al-Jazarī’s automata should be studied as sequenced mechanical action: timed state change, conditional triggers, repeatable cycles, mechanical embodiment, and documented reproducibility.",
    }

    write_csv(TABLES / "sequenced_action_themes.csv", themes)
    write_csv(TABLES / "sequenced_action_map.csv", scored)
    write_csv(TABLES / "interpretation_cautions.csv", cautions)
    write_csv(TABLES / "sequenced_action_summary.csv", [summary])

    write_json(JSON_DIR / "sequenced_action_config.json", asdict(config))
    write_json(JSON_DIR / "sequenced_action_map.json", scored)
    write_json(JSON_DIR / "interpretation_cautions.json", cautions)
    write_json(JSON_DIR / "sequenced_action_summary.json", summary)

    print("Al-Jazarī automata and sequenced mechanical action map complete.")
    print(TABLES / "sequenced_action_summary.csv")


if __name__ == "__main__":
    main()

This workflow turns sequenced mechanical action into a reproducible interpretive artifact: clocks, elephant clock sequence, cams, levers, water-raising machines, floats, vessels, musical automata, diagrams, debugging, historical significance, and caution are documented together.

Back to top ↑

R Workflow: Automata and Mechanical Action Diagnostics

The R workflow reads the generated CSV outputs, summarizes sequenced-action themes, visualizes theme dimensions, and writes an additional diagnostic table.

# al_jazari_automata_sequenced_action_summary.R
args <- commandArgs(trailingOnly = FALSE)
file_arg <- grep("^--file=", args, value = TRUE)

if (length(file_arg) > 0) {
  script_path <- normalizePath(sub("^--file=", "", file_arg[1]), mustWork = TRUE)
  article_root <- normalizePath(file.path(dirname(script_path), ".."), mustWork = TRUE)
} else {
  article_root <- getwd()
}

setwd(article_root)

tables_dir <- file.path(article_root, "outputs", "tables")
figures_dir <- file.path(article_root, "outputs", "figures")
dir.create(tables_dir, recursive = TRUE, showWarnings = FALSE)
dir.create(figures_dir, recursive = TRUE, showWarnings = FALSE)

map_path <- file.path(tables_dir, "sequenced_action_map.csv")
summary_path <- file.path(tables_dir, "sequenced_action_summary.csv")

if (!file.exists(map_path)) {
  stop(paste("Missing", map_path, "Run the Python workflow first."))
}

action_map <- read.csv(map_path, stringsAsFactors = FALSE)
summary <- read.csv(summary_path, stringsAsFactors = FALSE)

png(file.path(figures_dir, "sequenced_action_dimensions.png"), width = 1200, height = 850)
score_matrix <- t(as.matrix(action_map[, c("sequence_structure", "timing_control", "mechanical_embodiment", "conditional_action", "repeatability", "documentation_quality", "historical_significance", "ethical_caution", "modern_resonance")]))
barplot(score_matrix,
        beside = TRUE,
        names.arg = action_map$theme_id,
        las = 2,
        ylim = c(0, 1),
        ylab = "Interpretive Score",
        main = "Al-Jazarī Automata and Sequenced Mechanical Action Dimensions")
legend("bottomright",
       legend = rownames(score_matrix),
       cex = 0.70,
       bty = "n")
grid()
dev.off()

png(file.path(figures_dir, "sequenced_action_score_by_theme.png"), width = 1000, height = 750)
barplot(action_map$sequenced_action_score,
        names.arg = action_map$theme_id,
        las = 2,
        ylab = "Sequenced Action Score",
        main = "Sequenced Mechanical Action Score by Theme")
grid()
dev.off()

r_summary <- data.frame(
  themes_reviewed = summary$themes_reviewed[1],
  core_threads = summary$core_threads[1],
  major_threads = summary$major_threads[1],
  supporting_threads = summary$supporting_threads[1],
  mean_sequenced_action_score = summary$mean_sequenced_action_score[1],
  cautions = summary$cautions[1],
  diagnostic_note = "Al-Jazarī’s automata should be studied as sequenced mechanical action: timed state change, conditional triggers, repeatable cycles, mechanical embodiment, and documented reproducibility."
)

write.csv(r_summary, file.path(tables_dir, "r_sequenced_action_diagnostic_summary.csv"), row.names = FALSE)
print(r_summary)

The R layer makes the interpretive structure visible: clocks, timed state change, elephant clock sequence, cams, levers, floats, water-raising machines, musical automata, diagrams, implementation, and caution can be examined as related but distinct dimensions of sequenced mechanical action.

Back to top ↑

GitHub Repository

The companion repository contains reproducible workflows, synthetic interpretive data, outputs, calculators, documentation, and multilingual examples for this article.

Back to top ↑

A Practical Method for Studying Sequenced Mechanical Action

A careful study of sequenced mechanical action should ask how a device moves from one condition to another. The method below treats automata as embodied procedures while preserving historical difference.

This method treats automata as sequenced procedure in matter, not as modern software in disguise.

Back to top ↑

Common Pitfalls

The first pitfall is calling al-Jazarī’s devices modern robots. The second is treating diagrams as if they were source code. The third is ignoring courtly display and aesthetic purpose. The fourth is forgetting material constraints such as flow, leakage, weight, timing, wear, and calibration.

Al-Jazarī becomes more impressive, not less, when his devices are interpreted precisely.

Back to top ↑

Why Al-Jazarī Belongs in Algorithmic Reasoning

Al-Jazarī, automata, and sequenced mechanical action belong in algorithmic reasoning because they show how designed systems can produce ordered behavior. Clocks mark intervals. Figures move. Water lifts. Cams trigger. Floats sense level. Vessels hold state. Mechanisms reset. Diagrams document procedure.

This history expands the meaning of computation. Computation is not only symbolic calculation or digital execution. It is also the broader problem of making behavior reliable through structure. Al-Jazarī’s devices show procedure embodied in matter: timed, sequenced, constrained, repeatable, and visible.

The lesson for modern systems is direct. Every algorithm depends on implementation. It has a body: hardware, infrastructure, interface, energy, timing, maintenance, documentation, and social use. Al-Jazarī reminds us that automated behavior is never just abstract logic. It is a designed relation between structure and action. AI belongs in the toolkit, not in control.

Back to top ↑

Related Articles

• The Banū Mūsā and Mechanical Procedure
• Translation Movements and the Transmission of Algorithmic Knowledge
• Astronomical Tables, Calendars, and Algorithmic Prediction
• Algorithms in Systems Modeling
• AI Agents, Tool Use, and Procedural Autonomy

Back to top ↑

Further Reading

• al-Jazarī (1974) The Book of Knowledge of Ingenious Mechanical Devices. Translated and annotated by D.R. Hill. Dordrecht: D. Reidel.
• Hill, D.R. (1998) Studies in Medieval Islamic Technology. Aldershot: Ashgate.
• Hill, D.R. (1974) The Book of Knowledge of Ingenious Mechanical Devices. Dordrecht: D. Reidel.
• The Metropolitan Museum of Art (n.d.) ‘The Elephant Clock, Folio from a Book of the Knowledge of Ingenious Mechanical Devices by al-Jazarī’.
• The Public Domain Review (2012) ‘Manuscript of Ismail al-Jazarī’s Ingenious Mechanical Devices’.
• Britannica (2026) ‘Al-Jazarī’.
• Rosheim, M.E. (1994) Robot Evolution: The Development of Anthrobotics. New York: Wiley.

Back to top ↑

References

• al-Jazarī (1974) The Book of Knowledge of Ingenious Mechanical Devices. Translated and annotated by D.R. Hill. Dordrecht: D. Reidel.
• Britannica (2026) ‘Al-Jazarī’. Available at: https://www.britannica.com/biography/al-Jazari.
• Britannica (2026) ‘Automaton’. Available at: https://www.britannica.com/technology/automaton.
• Hill, D.R. (1998) Studies in Medieval Islamic Technology. Aldershot: Ashgate.
• The Metropolitan Museum of Art (n.d.) ‘The Elephant Clock, Folio from a Book of the Knowledge of Ingenious Mechanical Devices by al-Jazarī’. Available at: https://www.metmuseum.org/art/collection/search/451402.
• The Metropolitan Museum of Art (n.d.) ‘Design for a Water Clock in the Form of an Elephant’. Available at: https://www.metmuseum.org/art/collection/search/451300.
• The Public Domain Review (2012) ‘Manuscript of Ismail al-Jazarī’s Ingenious Mechanical Devices’. Available at: https://publicdomainreview.org/collection/arabic-machine-manuscript/.
• Rosheim, M.E. (1994) Robot Evolution: The Development of Anthrobotics. New York: Wiley.

Back to top ↑