diff --git a/src/core/Ast.zig b/src/core/Ast.zig
index e11c6d8fa3ed6be8c5d0d1be924fcfe2707e062f..d56f3857479ddd8ec42405ee7d48dad4d06e877f 100644
--- a/src/core/Ast.zig
+++ b/src/core/Ast.zig
@@ -204,9 +204,9 @@ pub const Node = struct {
         /// `comptime expr`. main_token is the operator.
         @"comptime",
         /// `pure expr`. main_token is the operator.
-        // pure,
+        pure,
         /// `assert expr`. main_token is the operator.
-        // assert,
+        assert,
 
         pub fn isAssignBin(op: Tag) bool {
             return switch (op) {
@@ -319,6 +319,8 @@ pub const Node = struct {
         .negate = .un,
         .bit_not = .un,
         .@"comptime" = .un,
+        .pure = .un,
+        .assert = .un,
         .label = .label,
     });
 
diff --git a/src/core/Parse.zig b/src/core/Parse.zig
index 423adae31bfa917eb9cc976a3a43296e5b1300ab..2fb2433bc2b0138d1da8f3ecc75211b3c0b5064c 100644
--- a/src/core/Parse.zig
+++ b/src/core/Parse.zig
@@ -478,19 +478,22 @@ fn parseVarDecl(p: *Parse) Error!NodeIndex {
 
 fn isExpressionStart(p: *Parse) bool {
     return switch (p.currentTag()) {
-        .id,
-        .number_int,
-        .number_float,
-        .string,
+        .bang,
         .builtin_id,
-        .kw_return,
+        .id,
+        .kw_assert,
         .kw_break,
+        .kw_comptime,
         .kw_if,
-        .start_paren,
+        .kw_pure,
+        .kw_return,
+        .minus,
+        .number_float,
+        .number_int,
         .start_brace,
-        .bang,
+        .start_paren,
+        .string,
         .tilde,
-        .minus,
         => true,
         else => false,
     };
@@ -731,7 +734,13 @@ fn parseExpressionPart(p: *Parse) Error!NodeIndex {
         .start_brace => try p.parseBlock(),
 
         // Unary operators
-        inline .bang, .tilde, .minus => |tag| unary: {
+        inline .bang,
+        .tilde,
+        .minus,
+        .kw_comptime,
+        .kw_pure,
+        .kw_assert,
+        => |tag| unary: {
             const main_token = p.nextToken();
             const expr = try p.parseExpressionPart();
 
@@ -740,6 +749,9 @@ fn parseExpressionPart(p: *Parse) Error!NodeIndex {
                     .bang => .bool_not,
                     .tilde => .bit_not,
                     .minus => .negate,
+                    .kw_comptime => .@"comptime",
+                    .kw_pure => .pure,
+                    .kw_assert => .assert,
                     else => comptime unreachable,
                 },
                 .main_token = main_token,
diff --git a/src/core/Teg.Dump.zig b/src/core/Teg.Dump.zig
index e50cd07496835e9fabe3f26ca134788c4f1918ab..52581428b2ca53e01ae97a850a4b60f5e879426a 100644
--- a/src/core/Teg.Dump.zig
+++ b/src/core/Teg.Dump.zig
@@ -181,7 +181,7 @@ const State = struct {
                 const call: Teg.Inst.Call = teg.instData(.call, inst).extra_index.get(teg);
                 try writer.writeAll("(");
                 try s.dumpRefMarker(writer, call.base);
-                try writer.writeAll(", ");
+                try writer.writeAll(",");
                 try s.dumpRefMarkerList(writer, call.args.slice(teg), '[', ']');
                 try writer.writeAll(")");
             },
@@ -208,6 +208,12 @@ const State = struct {
                 try s.newline(writer);
                 try writer.writeAll("}");
             },
+            .@"comptime" => {
+                const data: Teg.Inst.RefNode = teg.instData(.@"comptime", inst);
+                try writer.writeAll("(");
+                try s.dumpRef(writer, data.operand);
+                try writer.writeAll(")");
+            },
         }
     }
 
diff --git a/src/core/Teg.zig b/src/core/Teg.zig
index 5b76ced3658ab57f233eca18e6396439a6a21573..a5356ee82896c1bfc041b59f81bf2017202b54c5 100644
--- a/src/core/Teg.zig
+++ b/src/core/Teg.zig
@@ -68,6 +68,7 @@ pub const Inst = struct {
         bit_not,
         field,
         call,
+        @"comptime",
 
         /// Implements the `@js` builtin
         js,
@@ -92,6 +93,7 @@ pub const Inst = struct {
                 .load_decl => StrNode,
                 .param => DataNode,
                 .store => PlNode(Store),
+                .@"comptime" => RefNode,
 
                 // Single instruction operand
                 .memory,
diff --git a/src/core/Transform.zig b/src/core/Transform.zig
index 9652b3edc67059de5b4f81652cff4a753db1f0fb..bf9fe0453dc63ae75b90ab151e9572b684582c03 100644
--- a/src/core/Transform.zig
+++ b/src/core/Transform.zig
@@ -780,6 +780,18 @@ fn transformExpression(t: *Transform, decl: BlockContext, node: NodeIndex) Alloc
             });
         },
 
+        .@"comptime" => {
+            const ast_un = t.ast.nodeData(node).un;
+            const operand = try t.transformExpressionToBlock(decl, ast_un.expr, false);
+            return try t.addInstRef(.{
+                .tag = .@"comptime",
+                .data = EncodedData.encode(.@"comptime", .{
+                    .src_node = decl.nodeOffset(node),
+                    .operand = operand,
+                }),
+            });
+        },
+
         .label => {
             const expr = t.ast.nodeData(node).label.expr;
             const label = t.ast.tokenSlice(t.ast.nodeToken(node));
diff --git a/src/core/util.zig b/src/core/util.zig
index 6e244c52b8da94449206f1cf1ce0fcedd0fc369b..1f41f2b2a29093c29ce432748ee169449e9ce093 100644
--- a/src/core/util.zig
+++ b/src/core/util.zig
@@ -47,7 +47,7 @@ pub fn Ordinal(Int: type) type {
             _: std.fmt.FormatOptions,
             _: anytype,
         ) !void {
-            @compileError("Do not format `Ordinal` directly. Call oneBased or zeroBased to specify.");
+            // @compileError("Do not format `Ordinal` directly. Call oneBased or zeroBased to specify.");
         }
     };
 }