diff --git a/doc/langref.md b/doc/langref.md
index e1948d20ad2ba2e2321b39f667356535aa06f25d..c8cc3c588b73e542b332b3af3e22d9a0022c0c25 100644
--- a/doc/langref.md
+++ b/doc/langref.md
@@ -68,11 +68,11 @@ CompilerFnExpr : token(NumberSign) token(Symbol) token(LParen) Expression token(
 
 CompilerFnType : token(NumberSign) token(Symbol) token(LParen) Type token(RParen)
 
-PointerType : token(Ampersand) option(token(Const)) option(token(Restrict)) Type
+PointerType : token(Ampersand) option(token(Const)) option(token(NoAlias)) Type
 
 MaybeType : token(Question) Type
 
-ArrayType : token(LBracket) option(Expression) token(RBracket) option(token(Const)) option(token(Restrict)) Type
+ArrayType : token(LBracket) option(Expression) token(RBracket) option(token(Const)) option(token(NoAlias)) Type
 
 Block : token(LBrace) list(option(Statement), token(Semicolon)) token(RBrace)
 
diff --git a/doc/vim/syntax/zig.vim b/doc/vim/syntax/zig.vim
index c505a7e58c50c30ea44c2714b78601b51c20862c..5cc0aca16d6d6bbd26a7d5c4168adaf0e864a4db 100644
--- a/doc/vim/syntax/zig.vim
+++ b/doc/vim/syntax/zig.vim
@@ -8,7 +8,7 @@ if exists("b:current_syntax")
 endif
 
 syn keyword zigOperator as
-syn keyword zigStorage const var extern volatile export pub restrict
+syn keyword zigStorage const var extern volatile export pub noalias
 syn keyword zigStructure struct enum type
 syn keyword zigStatement goto break return continue asm
 syn keyword zigConditional if else match
diff --git a/src/analyze.cpp b/src/analyze.cpp
index 3f4462be71c728e47f13bdbdc9e4b1f72decf32a..141492689ae26527c5613946d4c09236439e63e8 100644
--- a/src/analyze.cpp
+++ b/src/analyze.cpp
@@ -135,8 +135,8 @@ static TypeTableEntry *get_number_literal_type_unsigned(CodeGen *g, uint64_t x)
     return g->num_lit_types[get_number_literal_kind_unsigned(x)];
 }
 
-TypeTableEntry *get_pointer_to_type(CodeGen *g, TypeTableEntry *child_type, bool is_const, bool is_restrict) {
-    TypeTableEntry **parent_pointer = &child_type->pointer_parent[(is_const ? 1 : 0)][(is_restrict ? 1 : 0)];
+TypeTableEntry *get_pointer_to_type(CodeGen *g, TypeTableEntry *child_type, bool is_const, bool is_noalias) {
+    TypeTableEntry **parent_pointer = &child_type->pointer_parent[(is_const ? 1 : 0)][(is_noalias ? 1 : 0)];
     if (*parent_pointer) {
         return *parent_pointer;
     } else {
@@ -151,7 +151,7 @@ TypeTableEntry *get_pointer_to_type(CodeGen *g, TypeTableEntry *child_type, bool
                 entry->size_in_bits, entry->align_in_bits, buf_ptr(&entry->name));
         entry->data.pointer.child_type = child_type;
         entry->data.pointer.is_const = is_const;
-        entry->data.pointer.is_restrict = is_restrict;
+        entry->data.pointer.is_noalias = is_noalias;
 
         *parent_pointer = entry;
         return entry;
@@ -240,9 +240,9 @@ static TypeTableEntry *get_array_type(CodeGen *g, ImportTableEntry *import,
 }
 
 static TypeTableEntry *get_unknown_size_array_type(CodeGen *g, ImportTableEntry *import,
-        TypeTableEntry *child_type, bool is_const, bool is_restrict)
+        TypeTableEntry *child_type, bool is_const, bool is_noalias)
 {
-    TypeTableEntry **parent_pointer = &child_type->unknown_size_array_parent[(is_const ? 1 : 0)][(is_restrict ? 1 : 0)];
+    TypeTableEntry **parent_pointer = &child_type->unknown_size_array_parent[(is_const ? 1 : 0)][(is_noalias ? 1 : 0)];
     if (*parent_pointer) {
         return *parent_pointer;
     } else {
@@ -252,7 +252,7 @@ static TypeTableEntry *get_unknown_size_array_type(CodeGen *g, ImportTableEntry
         buf_appendf(&entry->name, "[]%s", buf_ptr(&child_type->name));
         entry->type_ref = LLVMStructCreateNamed(LLVMGetGlobalContext(), buf_ptr(&entry->name));
 
-        TypeTableEntry *pointer_type = get_pointer_to_type(g, child_type, is_const, is_restrict);
+        TypeTableEntry *pointer_type = get_pointer_to_type(g, child_type, is_const, is_noalias);
 
         unsigned element_count = 2;
         LLVMTypeRef element_types[] = {
@@ -428,7 +428,7 @@ static TypeTableEntry *eval_const_expr(CodeGen *g, BlockContext *context,
 }
 
 static TypeTableEntry *resolve_type(CodeGen *g, AstNode *node, ImportTableEntry *import,
-        BlockContext *context, bool restrict_allowed)
+        BlockContext *context, bool noalias_allowed)
 {
     assert(node->type == NodeTypeType);
     alloc_codegen_node(node);
@@ -449,13 +449,13 @@ static TypeTableEntry *resolve_type(CodeGen *g, AstNode *node, ImportTableEntry
             }
         case AstNodeTypeTypePointer:
             {
-                bool use_restrict = false;
-                if (node->data.type.is_restrict) {
-                    if (!restrict_allowed) {
+                bool use_noalias = false;
+                if (node->data.type.is_noalias) {
+                    if (!noalias_allowed) {
                         add_node_error(g, node,
-                                buf_create_from_str("invalid restrict qualifier"));
+                                buf_create_from_str("invalid noalias qualifier"));
                     } else {
-                        use_restrict = true;
+                        use_noalias = true;
                     }
                 }
 
@@ -471,7 +471,7 @@ static TypeTableEntry *resolve_type(CodeGen *g, AstNode *node, ImportTableEntry
                     type_node->entry = child_type;
                     return child_type;
                 } else {
-                    type_node->entry = get_pointer_to_type(g, child_type, node->data.type.is_const, use_restrict);
+                    type_node->entry = get_pointer_to_type(g, child_type, node->data.type.is_const, use_noalias);
                     return type_node->entry;
                 }
             }
@@ -479,13 +479,13 @@ static TypeTableEntry *resolve_type(CodeGen *g, AstNode *node, ImportTableEntry
             {
                 AstNode *size_node = node->data.type.array_size;
 
-                bool use_restrict = false;
-                if (node->data.type.is_restrict) {
-                    if (!restrict_allowed || size_node) {
+                bool use_noalias = false;
+                if (node->data.type.is_noalias) {
+                    if (!noalias_allowed || size_node) {
                         add_node_error(g, node,
-                                buf_create_from_str("invalid restrict qualifier"));
+                                buf_create_from_str("invalid noalias qualifier"));
                     } else {
-                        use_restrict = true;
+                        use_noalias = true;
                     }
                 }
 
@@ -524,7 +524,7 @@ static TypeTableEntry *resolve_type(CodeGen *g, AstNode *node, ImportTableEntry
                     return type_node->entry;
                 } else {
                     type_node->entry = get_unknown_size_array_type(g, import, child_type,
-                            node->data.type.is_const, use_restrict);
+                            node->data.type.is_const, use_noalias);
                     return type_node->entry;
                 }
 
@@ -1221,7 +1221,7 @@ static TypeTableEntry *resolve_type_compatibility(CodeGen *g, BlockContext *cont
         return expected_type;
     }
 
-    // implicit non-const to const and ignore restrict
+    // implicit non-const to const and ignore noalias
     if (expected_type->id == TypeTableEntryIdPointer &&
         actual_type->id == TypeTableEntryIdPointer &&
         (!actual_type->data.pointer.is_const || expected_type->data.pointer.is_const))
diff --git a/src/analyze.hpp b/src/analyze.hpp
index 8785a4c6166fb1f30601d08273db775d7ed4ca30..37d1a49d3fcd6944ef30a53c36eefb8b773db7b2 100644
--- a/src/analyze.hpp
+++ b/src/analyze.hpp
@@ -23,7 +23,7 @@ struct StructValExprNode;
 struct TypeTableEntryPointer {
     TypeTableEntry *child_type;
     bool is_const;
-    bool is_restrict;
+    bool is_noalias;
 };
 
 struct TypeTableEntryInt {
@@ -98,8 +98,8 @@ struct TypeTableEntry {
     } data;
 
     // use these fields to make sure we don't duplicate type table entries for the same type
-    TypeTableEntry *pointer_parent[2][2]; // 0 - const. 1 - restrict
-    TypeTableEntry *unknown_size_array_parent[2][2]; // 0 - const. 1 - restrict
+    TypeTableEntry *pointer_parent[2][2]; // 0 - const. 1 - noalias
+    TypeTableEntry *unknown_size_array_parent[2][2]; // 0 - const. 1 - noalias
     HashMap<uint64_t, TypeTableEntry *, uint64_hash, uint64_eq> arrays_by_size;
     TypeTableEntry *maybe_parent;
 
@@ -391,7 +391,7 @@ void semantic_analyze(CodeGen *g);
 void add_node_error(CodeGen *g, AstNode *node, Buf *msg);
 void alloc_codegen_node(AstNode *node);
 TypeTableEntry *new_type_table_entry(TypeTableEntryId id);
-TypeTableEntry *get_pointer_to_type(CodeGen *g, TypeTableEntry *child_type, bool is_const, bool is_restrict);
+TypeTableEntry *get_pointer_to_type(CodeGen *g, TypeTableEntry *child_type, bool is_const, bool is_noalias);
 VariableTableEntry *find_variable(BlockContext *context, Buf *name);
 BlockContext *new_block_context(AstNode *node, BlockContext *parent);
 
diff --git a/src/codegen.cpp b/src/codegen.cpp
index b23757bee3d5acce2f154015e371cd5803c66ce9..6c7aaca341a433f4ded4a47de33f76b1bb0e5cf3 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -1840,7 +1840,7 @@ static void do_code_gen(CodeGen *g) {
             TypeTableEntry *param_type = fn_proto_type_from_type_node(g, type_node);
             LLVMValueRef argument_val = LLVMGetParam(fn, gen_param_index);
             if (param_type->id == TypeTableEntryIdPointer &&
-                param_type->data.pointer.is_restrict)
+                param_type->data.pointer.is_noalias)
             {
                 LLVMAddAttribute(argument_val, LLVMNoAliasAttribute);
             } else if (param_type->id == TypeTableEntryIdPointer &&
diff --git a/src/parser.cpp b/src/parser.cpp
index 828a2f6406e39f7221897a768ac99a9fae6d4ffb..567d5a9c0c3c94acc8aaa8256462ea1ad998d5d3 100644
--- a/src/parser.cpp
+++ b/src/parser.cpp
@@ -225,8 +225,8 @@ void ast_print(AstNode *node, int indent) {
                 case AstNodeTypeTypePointer:
                     {
                         const char *const_or_mut_str = node->data.type.is_const ? "const " : "";
-                        const char *restrict_or_not_str = node->data.type.is_restrict ? "restrict " : "";
-                        fprintf(stderr, "%s%s PointerType\n", const_or_mut_str, restrict_or_not_str);
+                        const char *noalias_or_not_str = node->data.type.is_noalias ? "noalias " : "";
+                        fprintf(stderr, "%s%s PointerType\n", const_or_mut_str, noalias_or_not_str);
 
                         ast_print(node->data.type.child_type, indent + 2);
                         break;
@@ -234,8 +234,8 @@ void ast_print(AstNode *node, int indent) {
                 case AstNodeTypeTypeArray:
                     {
                         const char *const_or_mut_str = node->data.type.is_const ? "const " : "";
-                        const char *restrict_or_not_str = node->data.type.is_restrict ? "restrict " : "";
-                        fprintf(stderr, "%s%s ArrayType\n", const_or_mut_str, restrict_or_not_str);
+                        const char *noalias_or_not_str = node->data.type.is_noalias ? "noalias " : "";
+                        fprintf(stderr, "%s%s ArrayType\n", const_or_mut_str, noalias_or_not_str);
                         if (node->data.type.array_size)
                             ast_print(node->data.type.array_size, indent + 2);
                         ast_print(node->data.type.child_type, indent + 2);
@@ -1024,12 +1024,12 @@ static void ast_parse_type_assume_amp(ParseContext *pc, int *token_index, AstNod
         node->data.type.is_const = true;
         *token_index += 1;
         first_type_token = &pc->tokens->at(*token_index);
-        if (first_type_token->id == TokenIdKeywordRestrict) {
-            node->data.type.is_restrict = true;
+        if (first_type_token->id == TokenIdKeywordNoAlias) {
+            node->data.type.is_noalias = true;
             *token_index += 1;
         }
-    } else if (first_type_token->id == TokenIdKeywordRestrict) {
-        node->data.type.is_restrict = true;
+    } else if (first_type_token->id == TokenIdKeywordNoAlias) {
+        node->data.type.is_noalias = true;
         *token_index += 1;
     }
 
@@ -1088,8 +1088,8 @@ static AstNode *ast_parse_compiler_fn_call(ParseContext *pc, int *token_index, b
 
 /*
 Type : token(Symbol) | token(Unreachable) | token(Void) | PointerType | ArrayType | MaybeType | CompilerFnExpr
-PointerType : token(Ampersand) option(token(Const)) option(token(Restrict)) Type
-ArrayType : token(LBracket) option(Expression) token(RBracket) option(token(Const)) option(token(Restrict)) Type
+PointerType : token(Ampersand) option(token(Const)) option(token(NoAlias)) Type
+ArrayType : token(LBracket) option(Expression) token(RBracket) option(token(Const)) option(token(NoAlias)) Type
 */
 static AstNode *ast_parse_type(ParseContext *pc, int *token_index) {
     Token *token = &pc->tokens->at(*token_index);
@@ -1140,13 +1140,13 @@ static AstNode *ast_parse_type(ParseContext *pc, int *token_index) {
             node->data.type.is_const = true;
 
             Token *next_tok = &pc->tokens->at(*token_index);
-            if (next_tok->id == TokenIdKeywordRestrict) {
+            if (next_tok->id == TokenIdKeywordNoAlias) {
                 *token_index += 1;
-                node->data.type.is_restrict = true;
+                node->data.type.is_noalias = true;
             }
-        } else if (const_tok->id == TokenIdKeywordRestrict) {
+        } else if (const_tok->id == TokenIdKeywordNoAlias) {
             *token_index += 1;
-            node->data.type.is_restrict = true;
+            node->data.type.is_noalias = true;
         }
 
         node->data.type.child_type = ast_parse_type(pc, token_index);
diff --git a/src/parser.hpp b/src/parser.hpp
index 4f7bed03b513082b94fa2f5337f1036c539a211e..46ef69db0216eb04e2e71b302d334837b199a0c0 100644
--- a/src/parser.hpp
+++ b/src/parser.hpp
@@ -110,7 +110,7 @@ struct AstNodeType {
     AstNode *child_type;
     AstNode *array_size; // can be null
     bool is_const;
-    bool is_restrict;
+    bool is_noalias;
     AstNode *compiler_expr;
 };
 
diff --git a/src/tokenizer.cpp b/src/tokenizer.cpp
index 6abaa8448aaab0e2e5ce4d03a2cf36833f83e86c..a9b09df46a75fad97ae305672b50fffc0fc10be6 100644
--- a/src/tokenizer.cpp
+++ b/src/tokenizer.cpp
@@ -243,8 +243,8 @@ static void end_token(Tokenize *t) {
         t->cur_tok->id = TokenIdKeywordBreak;
     } else if (mem_eql_str(token_mem, token_len, "null")) {
         t->cur_tok->id = TokenIdKeywordNull;
-    } else if (mem_eql_str(token_mem, token_len, "restrict")) {
-        t->cur_tok->id = TokenIdKeywordRestrict;
+    } else if (mem_eql_str(token_mem, token_len, "noalias")) {
+        t->cur_tok->id = TokenIdKeywordNoAlias;
     }
 
     t->cur_tok = nullptr;
@@ -1025,7 +1025,7 @@ static const char * token_name(Token *token) {
         case TokenIdKeywordContinue: return "Continue";
         case TokenIdKeywordBreak: return "Break";
         case TokenIdKeywordNull: return "Null";
-        case TokenIdKeywordRestrict: return "Restrict";
+        case TokenIdKeywordNoAlias: return "NoAlias";
         case TokenIdLParen: return "LParen";
         case TokenIdRParen: return "RParen";
         case TokenIdComma: return "Comma";
diff --git a/src/tokenizer.hpp b/src/tokenizer.hpp
index dc1da63a7bc9f0c0352e6bfa38dbc1194fb01e0c..a7b7a7713877442709975bfead2cc65f74a94f02 100644
--- a/src/tokenizer.hpp
+++ b/src/tokenizer.hpp
@@ -36,7 +36,7 @@ enum TokenId {
     TokenIdKeywordContinue,
     TokenIdKeywordBreak,
     TokenIdKeywordNull,
-    TokenIdKeywordRestrict,
+    TokenIdKeywordNoAlias,
     TokenIdLParen,
     TokenIdRParen,
     TokenIdComma,
diff --git a/std/builtin.zig b/std/builtin.zig
index b57c440c07924141309eb3ac172f8c788784ab89..eaaee2d6facf5d5e923f34136e64ed4b7c99981d 100644
--- a/std/builtin.zig
+++ b/std/builtin.zig
@@ -10,7 +10,7 @@ export fn memset(dest: &u8, c: u8, n: usize) -> &u8 {
     return dest;
 }
 
-export fn memcpy(dest: &restrict u8, src: &const restrict u8, n: usize) -> &u8 {
+export fn memcpy(dest: &noalias u8, src: &const noalias u8, n: usize) -> &u8 {
     var index : #typeof(n) = 0;
     while (index != n) {
         dest[index] = src[index];