diff --git a/config.json b/config.json
index 55c2a4c..428fc36 100644
--- a/config.json
+++ b/config.json
@@ -540,6 +540,14 @@
         "prerequisites": [],
         "difficulty": 4
       },
+      {
+        "slug": "prism",
+        "name": "Prism",
+        "uuid": "865a0901-4bdf-44c5-a0e9-5b87c104cb9d",
+        "practices": [],
+        "prerequisites": [],
+        "difficulty": 4
+      },
       {
         "slug": "roman-numerals",
         "name": "Roman Numerals",
diff --git a/exercises/practice/prism/.docs/instructions.md b/exercises/practice/prism/.docs/instructions.md
new file mode 100644
index 0000000..a68c80d
--- /dev/null
+++ b/exercises/practice/prism/.docs/instructions.md
@@ -0,0 +1,36 @@
+# Instructions
+
+Before activating the laser array, you must predict the exact order in which crystals will be hit, identified by their sample IDs.
+
+## Example Test Case
+
+Consider this crystal array configuration:
+
+```json
+{
+  "start": { "x": 0, "y": 0, "angle": 0 },
+  "prisms": [
+    { "id": 3, "x": 30, "y": 10, "angle": 45 },
+    { "id": 1, "x": 10, "y": 10, "angle": -90 },
+    { "id": 2, "x": 10, "y": 0, "angle": 90 },
+    { "id": 4, "x": 20, "y": 0, "angle": 0 }
+  ]
+}
+```
+
+## What's Happening
+
+The laser starts at the origin `(0, 0)` and fires horizontally to the right at angle 0°.
+Here's the step-by-step beam path:
+
+**Step 1**: The beam travels along the x-axis (y = 0) and first encounters **Crystal #2** at position `(10, 0)`.
+This crystal has a refraction angle of 90°, which means it bends the beam perpendicular to its current path.
+The beam, originally traveling at 0°, is now redirected to 90° (straight up).
+
+**Step 2**: The beam now travels vertically upward from position `(10, 0)` and strikes **Crystal #1** at position `(10, 10)`.
+This crystal has a refraction angle of -90°, bending the beam by -90° relative to its current direction.
+The beam was traveling at 90°, so after refraction it's now at 0° (90° + (-90°) = 0°), traveling horizontally to the right again.
+
+**Step 3**: From position `(10, 10)`, the beam travels horizontally and encounters **Crystal #3** at position `(30, 10)`.
+This crystal refracts the beam by 45°, changing its direction to 45°.
+The beam continues into empty space beyond the array.
diff --git a/exercises/practice/prism/.docs/introduction.md b/exercises/practice/prism/.docs/introduction.md
new file mode 100644
index 0000000..bfa7ed7
--- /dev/null
+++ b/exercises/practice/prism/.docs/introduction.md
@@ -0,0 +1,5 @@
+# Introduction
+
+You're a researcher at **PRISM** (Precariously Redirected Illumination Safety Management), working with a precision laser calibration system that tests experimental crystal prisms.
+These crystals are being developed for next-generation optical computers, and each one has unique refractive properties based on its molecular structure.
+The lab's laser system can damage crystals if they receive unexpected illumination, so precise path prediction is critical.
diff --git a/exercises/practice/prism/.meta/config.json b/exercises/practice/prism/.meta/config.json
new file mode 100644
index 0000000..573d70d
--- /dev/null
+++ b/exercises/practice/prism/.meta/config.json
@@ -0,0 +1,19 @@
+{
+  "authors": [
+    "IsaacG"
+  ],
+  "files": {
+    "solution": [
+      "prism.awk"
+    ],
+    "test": [
+      "test-prism.bats"
+    ],
+    "example": [
+      ".meta/example.awk"
+    ]
+  },
+  "blurb": "Calculate the path of a laser through reflective prisms.",
+  "source": "FraSanga",
+  "source_url": "https://github.com/exercism/problem-specifications/pull/2625"
+}
diff --git a/exercises/practice/prism/.meta/example.awk b/exercises/practice/prism/.meta/example.awk
new file mode 100644
index 0000000..a985f3d
--- /dev/null
+++ b/exercises/practice/prism/.meta/example.awk
@@ -0,0 +1,58 @@
+# The first line of input is the starting x, y and angle.
+# Any remaining input is the prisms: x, y, angle and ID.
+# The program is expected to print out prism IDs, space separated on one line.
+
+function abs(n) {
+    return (n > 0) ? n : -n
+}
+
+# Starting position
+NR == 1 { x = $1; y = $2; a = $3; }
+
+# Prism positions
+NR > 1 { prisms[$1]["x"] = $2; prisms[$1]["y"] = $3; prisms[$1]["a"] = $4; }
+
+# Compute the path
+END {
+    # Loop for hits until no more are found.
+    deg_to_rad = 3.141592 / 180
+    do {
+        found = 0
+        distance = 0
+        for (id in prisms) {
+            # Do not count a prism we just hit.
+            if (prisms[id]["x"] == x && prisms[id]["y"] == y) {
+                continue
+            }
+            dx = prisms[id]["x"] - x
+            dy = prisms[id]["y"] - y
+            r = sqrt(dx * dx + dy * dy)
+            # How close did we get to the prism?
+            hx = abs(cos(a * deg_to_rad) * r - dx)
+            hy = abs(sin(a * deg_to_rad) * r - dy)
+            if (hx < 0.1 && hy < 0.1) {
+                # Track the closest prism along the laser path
+                if (!found || r < distance) {
+                    fid = id
+                    distance = r
+                }
+                found = 1
+            }
+        }
+        if (found) {
+            x = prisms[fid]["x"]
+            y = prisms[fid]["y"]
+            a += prisms[fid]["a"]
+            out[count++] = fid
+        }
+    } while (found == 1)
+
+    # Print the prisms we hit, space separated IDs
+    if (count) {
+        res = out[0]
+        for (j = 1; j < count; j++) {
+            res = res " " out[j]
+        }
+        print res
+    }
+}
diff --git a/exercises/practice/prism/.meta/generate_tests b/exercises/practice/prism/.meta/generate_tests
new file mode 100644
index 0000000..28edf28
--- /dev/null
+++ b/exercises/practice/prism/.meta/generate_tests
@@ -0,0 +1,45 @@
+#!/usr/bin/env bash
+
+if (( BASH_VERSINFO[0] < 4 )); then
+    echo "[Failure] This script requires bash version 4+" >&2
+    exit 1
+fi
+
+if (( $# != 1 )) || [[ ${1##*/} != canonical-data.json ]]; then
+    echo "Usage: $0 <canonical-data.json for prism>"
+    exit 1
+fi
+
+printf '%s\n' '#!/usr/bin/env bats' 'load bats-extra'
+
+jq -r '
+    .cases |
+    # Add an index to each case, similar to Python enumerate()
+    [foreach .[] as $case ({"index": 0, "case": ""}; {"index": .index + 1, "case": $case})] |
+    map(
+        [
+            "",
+            "@test \"\(.case.description)\" {",
+            # Do not skip the first test
+            if .index == 1 then
+            "    # [[ $BATS_RUN_SKIPPED == \"true\" ]] || skip"
+            else
+            "    [[ $BATS_RUN_SKIPPED == \"true\" ]] || skip"
+            end,
+            "    run gawk -f prism.awk <<EOF",
+            # Start position
+            (.case.input.start | "\(.x) \(.y) \(.angle)"),
+            # Prism list
+            if (.case.input.prisms | length > 0) then
+                (.case.input.prisms | sort_by(.id) | map("\(.id) \(.x) \(.y) \(.angle)") | join("\n"))
+            else
+                empty
+            end,
+            "EOF",
+            "    assert_success",
+            "    assert_output \"" + (.case.expected.sequence | join(" ")) + "\"",
+            "}"
+        ] |
+        join("\n")
+    )
+    | join("\n")' "$1"
diff --git a/exercises/practice/prism/.meta/tests.toml b/exercises/practice/prism/.meta/tests.toml
new file mode 100644
index 0000000..b002223
--- /dev/null
+++ b/exercises/practice/prism/.meta/tests.toml
@@ -0,0 +1,52 @@
+# This is an auto-generated file.
+#
+# Regenerating this file via `configlet sync` will:
+# - Recreate every `description` key/value pair
+# - Recreate every `reimplements` key/value pair, where they exist in problem-specifications
+# - Remove any `include = true` key/value pair (an omitted `include` key implies inclusion)
+# - Preserve any other key/value pair
+#
+# As user-added comments (using the # character) will be removed when this file
+# is regenerated, comments can be added via a `comment` key.
+
+[ec65d3b3-f7bf-4015-8156-0609c141c4c4]
+description = "zero prisms"
+
+[ec0ca17c-0c5f-44fb-89ba-b76395bdaf1c]
+description = "one prism one hit"
+
+[0db955f2-0a27-4c82-ba67-197bd6202069]
+description = "one prism zero hits"
+
+[8d92485b-ebc0-4ee9-9b88-cdddb16b52da]
+description = "going up zero hits"
+
+[78295b3c-7438-492d-8010-9c63f5c223d7]
+description = "going down zero hits"
+
+[acc723ea-597b-4a50-8d1b-b980fe867d4c]
+description = "going left zero hits"
+
+[3f19b9df-9eaa-4f18-a2db-76132f466d17]
+description = "negative angle"
+
+[96dacffb-d821-4cdf-aed8-f152ce063195]
+description = "large angle"
+
+[513a7caa-957f-4c5d-9820-076842de113c]
+description = "upward refraction two hits"
+
+[d452b7c7-9761-4ea9-81a9-2de1d73eb9ef]
+description = "downward refraction two hits"
+
+[be1a2167-bf4c-4834-acc9-e4d68e1a0203]
+description = "same prism twice"
+
+[df5a60dd-7c7d-4937-ac4f-c832dae79e2e]
+description = "simple path"
+
+[8d9a3cc8-e846-4a3b-a137-4bfc4aa70bd1]
+description = "multiple prisms floating point precision"
+
+[e077fc91-4e4a-46b3-a0f5-0ba00321da56]
+description = "complex path with multiple prisms floating point precision"
diff --git a/exercises/practice/prism/bats-extra.bash b/exercises/practice/prism/bats-extra.bash
new file mode 100644
index 0000000..54d4807
--- /dev/null
+++ b/exercises/practice/prism/bats-extra.bash
@@ -0,0 +1,637 @@
+# This is the source code for bats-support and bats-assert, concatenated
+# * https://github.com/bats-core/bats-support
+# * https://github.com/bats-core/bats-assert
+#
+# Comments have been removed to save space. See the git repos for full source code.
+
+############################################################
+#
+# bats-support - Supporting library for Bats test helpers
+#
+# Written in 2016 by Zoltan Tombol <zoltan dot tombol at gmail dot com>
+#
+# To the extent possible under law, the author(s) have dedicated all
+# copyright and related and neighboring rights to this software to the
+# public domain worldwide. This software is distributed without any
+# warranty.
+#
+# You should have received a copy of the CC0 Public Domain Dedication
+# along with this software. If not, see
+# <http://creativecommons.org/publicdomain/zero/1.0/>.
+#
+
+fail() {
+  (( $# == 0 )) && batslib_err || batslib_err "$@"
+  return 1
+}
+
+batslib_is_caller() {
+  local -i is_mode_direct=1
+
+  # Handle options.
+  while (( $# > 0 )); do
+    case "$1" in
+      -i|--indirect) is_mode_direct=0; shift ;;
+      --) shift; break ;;
+      *) break ;;
+    esac
+  done
+
+  # Arguments.
+  local -r func="$1"
+
+  # Check call stack.
+  if (( is_mode_direct )); then
+    [[ $func == "${FUNCNAME[2]}" ]] && return 0
+  else
+    local -i depth
+    for (( depth=2; depth<${#FUNCNAME[@]}; ++depth )); do
+      [[ $func == "${FUNCNAME[$depth]}" ]] && return 0
+    done
+  fi
+
+  return 1
+}
+
+batslib_err() {
+  { if (( $# > 0 )); then
+      echo "$@"
+    else
+      cat -
+    fi
+  } >&2
+}
+
+batslib_count_lines() {
+  local -i n_lines=0
+  local line
+  while IFS='' read -r line || [[ -n $line ]]; do
+    (( ++n_lines ))
+  done < <(printf '%s' "$1")
+  echo "$n_lines"
+}
+
+batslib_is_single_line() {
+  for string in "$@"; do
+    (( $(batslib_count_lines "$string") > 1 )) && return 1
+  done
+  return 0
+}
+
+batslib_get_max_single_line_key_width() {
+  local -i max_len=-1
+  while (( $# != 0 )); do
+    local -i key_len="${#1}"
+    batslib_is_single_line "$2" && (( key_len > max_len )) && max_len="$key_len"
+    shift 2
+  done
+  echo "$max_len"
+}
+
+batslib_print_kv_single() {
+  local -ir col_width="$1"; shift
+  while (( $# != 0 )); do
+    printf '%-*s : %s\n' "$col_width" "$1" "$2"
+    shift 2
+  done
+}
+
+batslib_print_kv_multi() {
+  while (( $# != 0 )); do
+    printf '%s (%d lines):\n' "$1" "$( batslib_count_lines "$2" )"
+    printf '%s\n' "$2"
+    shift 2
+  done
+}
+
+batslib_print_kv_single_or_multi() {
+  local -ir width="$1"; shift
+  local -a pairs=( "$@" )
+
+  local -a values=()
+  local -i i
+  for (( i=1; i < ${#pairs[@]}; i+=2 )); do
+    values+=( "${pairs[$i]}" )
+  done
+
+  if batslib_is_single_line "${values[@]}"; then
+    batslib_print_kv_single "$width" "${pairs[@]}"
+  else
+    local -i i
+    for (( i=1; i < ${#pairs[@]}; i+=2 )); do
+      pairs[$i]="$( batslib_prefix < <(printf '%s' "${pairs[$i]}") )"
+    done
+    batslib_print_kv_multi "${pairs[@]}"
+  fi
+}
+
+batslib_prefix() {
+  local -r prefix="${1:-  }"
+  local line
+  while IFS='' read -r line || [[ -n $line ]]; do
+    printf '%s%s\n' "$prefix" "$line"
+  done
+}
+
+batslib_mark() {
+  local -r symbol="$1"; shift
+  # Sort line numbers.
+  set -- $( sort -nu <<< "$( printf '%d\n' "$@" )" )
+
+  local line
+  local -i idx=0
+  while IFS='' read -r line || [[ -n $line ]]; do
+    if (( ${1:--1} == idx )); then
+      printf '%s\n' "${symbol}${line:${#symbol}}"
+      shift
+    else
+      printf '%s\n' "$line"
+    fi
+    (( ++idx ))
+  done
+}
+
+batslib_decorate() {
+  echo
+  echo "-- $1 --"
+  cat -
+  echo '--'
+  echo
+}
+
+############################################################
+
+assert() {
+  if ! "$@"; then
+    batslib_print_kv_single 10 'expression' "$*" \
+    | batslib_decorate 'assertion failed' \
+    | fail
+  fi
+}
+
+assert_equal() {
+  if [[ $1 != "$2" ]]; then
+    batslib_print_kv_single_or_multi 8 \
+    'expected' "$2" \
+    'actual'   "$1" \
+    | batslib_decorate 'values do not equal' \
+    | fail
+  fi
+}
+
+assert_failure() {
+  : "${output?}"
+  : "${status?}"
+
+  (( $# > 0 )) && local -r expected="$1"
+  if (( status == 0 )); then
+    batslib_print_kv_single_or_multi 6 'output' "$output" \
+    | batslib_decorate 'command succeeded, but it was expected to fail' \
+    | fail
+  elif (( $# > 0 )) && (( status != expected )); then
+    { local -ir width=8
+      batslib_print_kv_single "$width" \
+      'expected' "$expected" \
+      'actual'   "$status"
+      batslib_print_kv_single_or_multi "$width" \
+      'output' "$output"
+    } \
+    | batslib_decorate 'command failed as expected, but status differs' \
+    | fail
+  fi
+}
+
+assert_line() {
+  local -i is_match_line=0
+  local -i is_mode_partial=0
+  local -i is_mode_regexp=0
+  : "${lines?}"
+
+  # Handle options.
+  while (( $# > 0 )); do
+    case "$1" in
+    -n|--index)
+      if (( $# < 2 )) || ! [[ $2 =~ ^([0-9]|[1-9][0-9]+)$ ]]; then
+        echo "\`--index' requires an integer argument: \`$2'" \
+        | batslib_decorate 'ERROR: assert_line' \
+        | fail
+        return $?
+      fi
+      is_match_line=1
+      local -ri idx="$2"
+      shift 2
+      ;;
+    -p|--partial) is_mode_partial=1; shift ;;
+    -e|--regexp) is_mode_regexp=1; shift ;;
+    --) shift; break ;;
+    *) break ;;
+    esac
+  done
+
+  if (( is_mode_partial )) && (( is_mode_regexp )); then
+    echo "\`--partial' and \`--regexp' are mutually exclusive" \
+    | batslib_decorate 'ERROR: assert_line' \
+    | fail
+    return $?
+  fi
+
+  # Arguments.
+  local -r expected="$1"
+
+  if (( is_mode_regexp == 1 )) && [[ '' =~ $expected ]] || (( $? == 2 )); then
+    echo "Invalid extended regular expression: \`$expected'" \
+    | batslib_decorate 'ERROR: assert_line' \
+    | fail
+    return $?
+  fi
+
+  # Matching.
+  if (( is_match_line )); then
+    # Specific line.
+    if (( is_mode_regexp )); then
+      if ! [[ ${lines[$idx]} =~ $expected ]]; then
+        batslib_print_kv_single 6 \
+        'index' "$idx" \
+        'regexp' "$expected" \
+        'line'  "${lines[$idx]}" \
+        | batslib_decorate 'regular expression does not match line' \
+        | fail
+      fi
+    elif (( is_mode_partial )); then
+      if [[ ${lines[$idx]} != *"$expected"* ]]; then
+        batslib_print_kv_single 9 \
+        'index'     "$idx" \
+        'substring' "$expected" \
+        'line'      "${lines[$idx]}" \
+        | batslib_decorate 'line does not contain substring' \
+        | fail
+      fi
+    else
+      if [[ ${lines[$idx]} != "$expected" ]]; then
+        batslib_print_kv_single 8 \
+        'index'    "$idx" \
+        'expected' "$expected" \
+        'actual'   "${lines[$idx]}" \
+        | batslib_decorate 'line differs' \
+        | fail
+      fi
+    fi
+  else
+    # Contained in output.
+    if (( is_mode_regexp )); then
+      local -i idx
+      for (( idx = 0; idx < ${#lines[@]}; ++idx )); do
+        [[ ${lines[$idx]} =~ $expected ]] && return 0
+      done
+      { local -ar single=( 'regexp' "$expected" )
+        local -ar may_be_multi=( 'output' "$output" )
+        local -ir width="$( batslib_get_max_single_line_key_width "${single[@]}" "${may_be_multi[@]}" )"
+        batslib_print_kv_single "$width" "${single[@]}"
+        batslib_print_kv_single_or_multi "$width" "${may_be_multi[@]}"
+      } \
+      | batslib_decorate 'no output line matches regular expression' \
+      | fail
+    elif (( is_mode_partial )); then
+      local -i idx
+      for (( idx = 0; idx < ${#lines[@]}; ++idx )); do
+        [[ ${lines[$idx]} == *"$expected"* ]] && return 0
+      done
+      { local -ar single=( 'substring' "$expected" )
+        local -ar may_be_multi=( 'output' "$output" )
+        local -ir width="$( batslib_get_max_single_line_key_width "${single[@]}" "${may_be_multi[@]}" )"
+        batslib_print_kv_single "$width" "${single[@]}"
+        batslib_print_kv_single_or_multi "$width" "${may_be_multi[@]}"
+      } \
+      | batslib_decorate 'no output line contains substring' \
+      | fail
+    else
+      local -i idx
+      for (( idx = 0; idx < ${#lines[@]}; ++idx )); do
+        [[ ${lines[$idx]} == "$expected" ]] && return 0
+      done
+      { local -ar single=( 'line' "$expected" )
+        local -ar may_be_multi=( 'output' "$output" )
+        local -ir width="$( batslib_get_max_single_line_key_width "${single[@]}" "${may_be_multi[@]}" )"
+        batslib_print_kv_single "$width" "${single[@]}"
+        batslib_print_kv_single_or_multi "$width" "${may_be_multi[@]}"
+      } \
+      | batslib_decorate 'output does not contain line' \
+      | fail
+    fi
+  fi
+}
+
+assert_output() {
+  local -i is_mode_partial=0
+  local -i is_mode_regexp=0
+  local -i is_mode_nonempty=0
+  local -i use_stdin=0
+  : "${output?}"
+
+  # Handle options.
+  if (( $# == 0 )); then
+    is_mode_nonempty=1
+  fi
+
+  while (( $# > 0 )); do
+    case "$1" in
+    -p|--partial) is_mode_partial=1; shift ;;
+    -e|--regexp) is_mode_regexp=1; shift ;;
+    -|--stdin) use_stdin=1; shift ;;
+    --) shift; break ;;
+    *) break ;;
+    esac
+  done
+
+  if (( is_mode_partial )) && (( is_mode_regexp )); then
+    echo "\`--partial' and \`--regexp' are mutually exclusive" \
+    | batslib_decorate 'ERROR: assert_output' \
+    | fail
+    return $?
+  fi
+
+  # Arguments.
+  local expected
+  if (( use_stdin )); then
+    expected="$(cat -)"
+  else
+    expected="${1-}"
+  fi
+
+  # Matching.
+  if (( is_mode_nonempty )); then
+    if [ -z "$output" ]; then
+      echo 'expected non-empty output, but output was empty' \
+      | batslib_decorate 'no output' \
+      | fail
+    fi
+  elif (( is_mode_regexp )); then
+    if [[ '' =~ $expected ]] || (( $? == 2 )); then
+      echo "Invalid extended regular expression: \`$expected'" \
+      | batslib_decorate 'ERROR: assert_output' \
+      | fail
+    elif ! [[ $output =~ $expected ]]; then
+      batslib_print_kv_single_or_multi 6 \
+      'regexp'  "$expected" \
+      'output' "$output" \
+      | batslib_decorate 'regular expression does not match output' \
+      | fail
+    fi
+  elif (( is_mode_partial )); then
+    if [[ $output != *"$expected"* ]]; then
+      batslib_print_kv_single_or_multi 9 \
+      'substring' "$expected" \
+      'output'    "$output" \
+      | batslib_decorate 'output does not contain substring' \
+      | fail
+    fi
+  else
+    if [[ $output != "$expected" ]]; then
+      batslib_print_kv_single_or_multi 8 \
+      'expected' "$expected" \
+      'actual'   "$output" \
+      | batslib_decorate 'output differs' \
+      | fail
+    fi
+  fi
+}
+
+assert_success() {
+  : "${output?}"
+  : "${status?}"
+
+  if (( status != 0 )); then
+    { local -ir width=6
+      batslib_print_kv_single "$width" 'status' "$status"
+      batslib_print_kv_single_or_multi "$width" 'output' "$output"
+    } \
+    | batslib_decorate 'command failed' \
+    | fail
+  fi
+}
+
+refute() {
+  if "$@"; then
+    batslib_print_kv_single 10 'expression' "$*" \
+    | batslib_decorate 'assertion succeeded, but it was expected to fail' \
+    | fail
+  fi
+}
+
+refute_line() {
+  local -i is_match_line=0
+  local -i is_mode_partial=0
+  local -i is_mode_regexp=0
+  : "${lines?}"
+
+  # Handle options.
+  while (( $# > 0 )); do
+    case "$1" in
+    -n|--index)
+      if (( $# < 2 )) || ! [[ $2 =~ ^([0-9]|[1-9][0-9]+)$ ]]; then
+        echo "\`--index' requires an integer argument: \`$2'" \
+        | batslib_decorate 'ERROR: refute_line' \
+        | fail
+        return $?
+      fi
+      is_match_line=1
+      local -ri idx="$2"
+      shift 2
+      ;;
+    -p|--partial) is_mode_partial=1; shift ;;
+    -e|--regexp) is_mode_regexp=1; shift ;;
+    --) shift; break ;;
+    *) break ;;
+    esac
+  done
+
+  if (( is_mode_partial )) && (( is_mode_regexp )); then
+    echo "\`--partial' and \`--regexp' are mutually exclusive" \
+    | batslib_decorate 'ERROR: refute_line' \
+    | fail
+    return $?
+  fi
+
+  # Arguments.
+  local -r unexpected="$1"
+
+  if (( is_mode_regexp == 1 )) && [[ '' =~ $unexpected ]] || (( $? == 2 )); then
+    echo "Invalid extended regular expression: \`$unexpected'" \
+    | batslib_decorate 'ERROR: refute_line' \
+    | fail
+    return $?
+  fi
+
+  # Matching.
+  if (( is_match_line )); then
+    # Specific line.
+    if (( is_mode_regexp )); then
+      if [[ ${lines[$idx]} =~ $unexpected ]]; then
+        batslib_print_kv_single 6 \
+        'index' "$idx" \
+        'regexp' "$unexpected" \
+        'line'  "${lines[$idx]}" \
+        | batslib_decorate 'regular expression should not match line' \
+        | fail
+      fi
+    elif (( is_mode_partial )); then
+      if [[ ${lines[$idx]} == *"$unexpected"* ]]; then
+        batslib_print_kv_single 9 \
+        'index'     "$idx" \
+        'substring' "$unexpected" \
+        'line'      "${lines[$idx]}" \
+        | batslib_decorate 'line should not contain substring' \
+        | fail
+      fi
+    else
+      if [[ ${lines[$idx]} == "$unexpected" ]]; then
+        batslib_print_kv_single 5 \
+        'index' "$idx" \
+        'line'  "${lines[$idx]}" \
+        | batslib_decorate 'line should differ' \
+        | fail
+      fi
+    fi
+  else
+    # Line contained in output.
+    if (( is_mode_regexp )); then
+      local -i idx
+      for (( idx = 0; idx < ${#lines[@]}; ++idx )); do
+        if [[ ${lines[$idx]} =~ $unexpected ]]; then
+          { local -ar single=( 'regexp' "$unexpected" 'index' "$idx" )
+            local -a may_be_multi=( 'output' "$output" )
+            local -ir width="$( batslib_get_max_single_line_key_width "${single[@]}" "${may_be_multi[@]}" )"
+            batslib_print_kv_single "$width" "${single[@]}"
+            if batslib_is_single_line "${may_be_multi[1]}"; then
+              batslib_print_kv_single "$width" "${may_be_multi[@]}"
+            else
+              may_be_multi[1]="$( printf '%s' "${may_be_multi[1]}" | batslib_prefix | batslib_mark '>' "$idx" )"
+              batslib_print_kv_multi "${may_be_multi[@]}"
+            fi
+          } \
+          | batslib_decorate 'no line should match the regular expression' \
+          | fail
+          return $?
+        fi
+      done
+    elif (( is_mode_partial )); then
+      local -i idx
+      for (( idx = 0; idx < ${#lines[@]}; ++idx )); do
+        if [[ ${lines[$idx]} == *"$unexpected"* ]]; then
+          { local -ar single=( 'substring' "$unexpected" 'index' "$idx" )
+            local -a may_be_multi=( 'output' "$output" )
+            local -ir width="$( batslib_get_max_single_line_key_width "${single[@]}" "${may_be_multi[@]}" )"
+            batslib_print_kv_single "$width" "${single[@]}"
+            if batslib_is_single_line "${may_be_multi[1]}"; then
+              batslib_print_kv_single "$width" "${may_be_multi[@]}"
+            else
+              may_be_multi[1]="$( printf '%s' "${may_be_multi[1]}" | batslib_prefix | batslib_mark '>' "$idx" )"
+              batslib_print_kv_multi "${may_be_multi[@]}"
+            fi
+          } \
+          | batslib_decorate 'no line should contain substring' \
+          | fail
+          return $?
+        fi
+      done
+    else
+      local -i idx
+      for (( idx = 0; idx < ${#lines[@]}; ++idx )); do
+        if [[ ${lines[$idx]} == "$unexpected" ]]; then
+          { local -ar single=( 'line' "$unexpected" 'index' "$idx" )
+            local -a may_be_multi=( 'output' "$output" )
+            local -ir width="$( batslib_get_max_single_line_key_width "${single[@]}" "${may_be_multi[@]}" )"
+            batslib_print_kv_single "$width" "${single[@]}"
+            if batslib_is_single_line "${may_be_multi[1]}"; then
+              batslib_print_kv_single "$width" "${may_be_multi[@]}"
+            else
+              may_be_multi[1]="$( printf '%s' "${may_be_multi[1]}" | batslib_prefix | batslib_mark '>' "$idx" )"
+              batslib_print_kv_multi "${may_be_multi[@]}"
+            fi
+          } \
+          | batslib_decorate 'line should not be in output' \
+          | fail
+          return $?
+        fi
+      done
+    fi
+  fi
+}
+
+refute_output() {
+  local -i is_mode_partial=0
+  local -i is_mode_regexp=0
+  local -i is_mode_empty=0
+  local -i use_stdin=0
+  : "${output?}"
+
+  # Handle options.
+  if (( $# == 0 )); then
+    is_mode_empty=1
+  fi
+
+  while (( $# > 0 )); do
+    case "$1" in
+    -p|--partial) is_mode_partial=1; shift ;;
+    -e|--regexp) is_mode_regexp=1; shift ;;
+    -|--stdin) use_stdin=1; shift ;;
+    --) shift; break ;;
+    *) break ;;
+    esac
+  done
+
+  if (( is_mode_partial )) && (( is_mode_regexp )); then
+    echo "\`--partial' and \`--regexp' are mutually exclusive" \
+    | batslib_decorate 'ERROR: refute_output' \
+    | fail
+    return $?
+  fi
+
+  # Arguments.
+  local unexpected
+  if (( use_stdin )); then
+    unexpected="$(cat -)"
+  else
+    unexpected="${1-}"
+  fi
+
+  if (( is_mode_regexp == 1 )) && [[ '' =~ $unexpected ]] || (( $? == 2 )); then
+    echo "Invalid extended regular expression: \`$unexpected'" \
+    | batslib_decorate 'ERROR: refute_output' \
+    | fail
+    return $?
+  fi
+
+  # Matching.
+  if (( is_mode_empty )); then
+    if [ -n "$output" ]; then
+      batslib_print_kv_single_or_multi 6 \
+      'output' "$output" \
+      | batslib_decorate 'output non-empty, but expected no output' \
+      | fail
+    fi
+  elif (( is_mode_regexp )); then
+    if [[ $output =~ $unexpected ]]; then
+      batslib_print_kv_single_or_multi 6 \
+      'regexp'  "$unexpected" \
+      'output' "$output" \
+      | batslib_decorate 'regular expression should not match output' \
+      | fail
+    fi
+  elif (( is_mode_partial )); then
+    if [[ $output == *"$unexpected"* ]]; then
+      batslib_print_kv_single_or_multi 9 \
+      'substring' "$unexpected" \
+      'output'    "$output" \
+      | batslib_decorate 'output should not contain substring' \
+      | fail
+    fi
+  else
+    if [[ $output == "$unexpected" ]]; then
+      batslib_print_kv_single_or_multi 6 \
+      'output' "$output" \
+      | batslib_decorate 'output equals, but it was expected to differ' \
+      | fail
+    fi
+  fi
+}
diff --git a/exercises/practice/prism/prism.awk b/exercises/practice/prism/prism.awk
new file mode 100644
index 0000000..5d52b2c
--- /dev/null
+++ b/exercises/practice/prism/prism.awk
@@ -0,0 +1,8 @@
+# The first line of input is the starting x, y and angle.
+# Any remaining input is the prisms: ID, x, y, and refraction angle.
+# The program is expected to print out prism IDs, space separated on one line.
+
+BEGIN {
+    print "Implement this solution" > "/dev/stderr"
+    exit 1
+}
diff --git a/exercises/practice/prism/test-prism.bats b/exercises/practice/prism/test-prism.bats
new file mode 100644
index 0000000..f8360d5
--- /dev/null
+++ b/exercises/practice/prism/test-prism.bats
@@ -0,0 +1,267 @@
+#!/usr/bin/env bats
+load bats-extra
+
+@test "zero prisms" {
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f prism.awk <<EOF
+0 0 0
+EOF
+    assert_success
+    assert_output ""
+}
+
+@test "one prism one hit" {
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f prism.awk <<EOF
+0 0 0
+1 10 0 0
+EOF
+    assert_success
+    assert_output "1"
+}
+
+@test "one prism zero hits" {
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f prism.awk <<EOF
+0 0 0
+1 -10 0 0
+EOF
+    assert_success
+    assert_output ""
+}
+
+@test "going up zero hits" {
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f prism.awk <<EOF
+0 0 90
+1 -10 0 0
+2 10 0 0
+3 0 -10 0
+EOF
+    assert_success
+    assert_output ""
+}
+
+@test "going down zero hits" {
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f prism.awk <<EOF
+0 0 -90
+1 10 0 0
+2 0 10 0
+3 -10 0 0
+EOF
+    assert_success
+    assert_output ""
+}
+
+@test "going left zero hits" {
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f prism.awk <<EOF
+0 0 180
+1 0 -10 0
+2 0 10 0
+3 10 0 0
+EOF
+    assert_success
+    assert_output ""
+}
+
+@test "negative angle" {
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f prism.awk <<EOF
+0 0 -180
+1 0 -10 0
+2 0 10 0
+3 10 0 0
+EOF
+    assert_success
+    assert_output ""
+}
+
+@test "large angle" {
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f prism.awk <<EOF
+0 0 2340
+1 10 0 0
+EOF
+    assert_success
+    assert_output ""
+}
+
+@test "upward refraction two hits" {
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f prism.awk <<EOF
+0 0 0
+1 10 10 0
+2 10 0 90
+EOF
+    assert_success
+    assert_output "2 1"
+}
+
+@test "downward refraction two hits" {
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f prism.awk <<EOF
+0 0 0
+1 10 0 -90
+2 10 -10 0
+EOF
+    assert_success
+    assert_output "1 2"
+}
+
+@test "same prism twice" {
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f prism.awk <<EOF
+0 0 0
+1 20 0 -180
+2 10 0 0
+EOF
+    assert_success
+    assert_output "2 1 2"
+}
+
+@test "simple path" {
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f prism.awk <<EOF
+0 0 0
+1 10 10 -90
+2 10 0 90
+3 30 10 45
+4 20 0 0
+EOF
+    assert_success
+    assert_output "2 1 3"
+}
+
+@test "multiple prisms floating point precision" {
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f prism.awk <<EOF
+0 0 -6.429
+1 13.2 77.0 17.937
+2 0.0 42.4 -21.817
+3 -6.6 3.2 46.72
+4 29.0 75.4 17.016
+5 23.2 80.2 31.866
+6 1.0 80.6 51.295
+7 14.2 -1.6 19.081
+8 -10.0 15.8 -9.24
+9 30.8 41.8 -165.413
+10 37.8 55.2 11.978
+11 15.4 82.6 66.262
+12 -1.0 0.2 0.0
+13 48.6 51.8 45.812
+14 -2.0 34.4 -52.001
+15 -3.0 79.2 53.782
+16 30.8 6.6 35.852
+17 -4.4 74.6 24.709
+18 -26.0 42.6 22.661
+19 -13.8 24.2 -9.205
+20 20.4 82.8 45.17
+21 24.4 75.8 20.783
+22 47.0 57.8 54.745
+23 41.6 59.8 70.763
+24 36.2 65.2 -0.304
+25 38.8 76.2 51.958
+26 5.8 73.4 6.555
+27 -5.6 32.8 -75.303
+28 36.4 31.4 -18.157
+29 31.4 79.4 61.327
+30 24.0 0.6 28.771
+31 -20.2 48.8 30.615
+32 4.2 78.6 40.892
+33 11.2 44.4 -165.941
+34 -8.8 36.8 -4.199
+35 21.4 44.8 -171.579
+36 -27.0 47.8 92.52
+37 -15.8 47.0 33.29
+38 36.4 79.2 49.05
+EOF
+    assert_success
+    assert_output "7 30 16 28 13 22 23 10 9 24 25 38 29 4 35 21 5 20 11 1 33 26 32 6 15 17 2 14 27 34 37 31 36 18 19 8 3 12"
+}
+
+@test "complex path with multiple prisms floating point precision" {
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f prism.awk <<EOF
+0 0 0.0
+1 83.0 0.2 89.105
+2 89.8 27.8 91.176
+3 22.4 7.0 -91.685
+4 82.6 27.6 71.127
+5 -65.2 21.6 93.128
+6 90.0 0.2 90.415
+7 -72.6 6.4 -89.148
+8 -31.6 30.8 0.535
+9 -51.4 31.6 67.249
+10 74.4 0.4 90.939
+11 64.4 -0.2 92.353
+12 59.0 5.0 -91.164
+13 34.4 7.0 90.0
+14 -79.6 32.4 92.342
+15 67.6 0.4 84.958
+16 -47.4 11.4 -136.02
+17 -52.2 17.8 -52.938
+18 -46.2 19.2 -128.362
+19 53.2 20.6 -87.181
+20 45.8 -0.2 1.469
+21 -41.8 0.0 68.352
+22 75.2 28.0 63.515
+23 9.8 30.8 30.829
+24 63.8 14.4 86.586
+25 78.6 7.8 98.562
+26 -39.8 30.8 61.113
+27 -4.6 0.2 87.397
+28 38.0 0.0 86.863
+29 47.2 28.2 92.954
+30 -34.2 0.6 111.33
+31 -58.0 6.6 -61.837
+32 -9.0 0.0 91.615
+33 -16.4 18.4 90.734
+34 -9.4 23.2 -88.238
+35 14.8 -0.4 89.176
+36 -24.2 8.2 -90.0
+37 -16.6 13.2 84.785
+38 53.0 14.6 -90.848
+39 -12.0 8.2 90.0
+40 -65.0 14.0 87.109
+41 -12.0 0.0 91.219
+42 65.8 20.8 -85.867
+43 7.0 0.0 116.565
+44 -0.8 15.6 -116.565
+45 10.6 18.8 23.697
+46 37.4 20.6 -88.332
+47 45.4 5.8 -82.992
+48 -4.6 10.0 -161.222
+49 34.4 -0.2 89.415
+50 -24.2 12.8 -86.987
+51 -72.6 21.0 -100.976
+52 14.2 24.0 -143.896
+53 -1.2 0.0 0.0
+54 44.0 27.8 85.969
+55 -61.4 26.4 94.086
+56 -51.0 0.2 70.445
+57 -61.8 32.0 84.627
+58 -79.0 -0.2 89.481
+59 82.8 13.0 -140.177
+60 -58.8 31.6 115.56
+61 -72.0 26.4 -83.66
+62 -32.0 24.8 -140.8
+63 74.2 12.6 -138.429
+64 59.2 10.2 -92.203
+65 48.0 10.2 87.455
+66 5.4 15.6 31.608
+67 79.8 18.6 -136.643
+68 14.6 28.0 -29.867
+69 22.8 20.6 -88.315
+70 -72.8 13.4 -87.238
+71 -24.2 18.6 -88.531
+72 -24.2 23.4 -90.774
+73 -40.4 13.4 -62.229
+74 -30.8 0.4 85.966
+75 -10.2 30.6 -1.108
+76 -57.6 0.0 1.2
+EOF
+    assert_success
+    assert_output "43 44 66 45 52 35 49 13 3 69 46 28 20 11 24 38 19 42 15 10 63 25 59 1 6 2 4 67 22 29 65 64 12 47 54 68 23 75 8 26 18 9 60 17 31 7 70 40 5 51 61 55 57 14 58 76 56 16 21 30 73 62 74 41 39 36 50 37 33 71 72 34 32 27 48 53"
+}