diff --git a/nixd/include/nixd/Parser/Epilogue.cpp b/nixd/include/nixd/Parser/Epilogue.cpp
deleted file mode 100644
index 2fb356a5c..000000000
--- a/nixd/include/nixd/Parser/Epilogue.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-#pragma once
-
-#include "Parser.tab.h"
-
-#include "Lexer.tab.h"
-
-#include "nixd/Expr/Expr.h"
-
-#include <nix/eval.hh>
-#include <nix/fetchers.hh>
-#include <nix/filetransfer.hh>
-#include <nix/flake/flake.hh>
-#include <nix/nixexpr.hh>
-#include <nix/store-api.hh>
-#include <nix/symbol-table.hh>
-
-#include <fcntl.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <unistd.h>
-
-namespace nixd {
-
-using namespace nix;
-
-std::unique_ptr<ParseData> parse(char *text, size_t length, Pos::Origin origin,
-                                 const SourcePath &basePath, ParseState state) {
-  yyscan_t scanner;
-  std::unique_ptr<ParseData> data = std::unique_ptr<ParseData>(new ParseData{
-      .state =
-          {
-              .symbols = state.symbols,
-              .positions = state.positions,
-          },
-      .basePath = std::move(basePath),
-      .origin = {origin},
-  });
-
-  yylex_init(&scanner);
-  yy_scan_buffer(text, length, scanner);
-  yyparse(scanner, data.get());
-  yylex_destroy(scanner);
-  data->STable = std::make_unique<nix::SymbolTable>(state.symbols);
-  data->PTable = std::make_unique<nix::PosTable>(state.positions);
-  return data; // NRVO
-}
-
-} // namespace nixd
diff --git a/nixd/include/nixd/Parser/Parser.h b/nixd/include/nixd/Parser/Parser.h
deleted file mode 100644
index 9ccb6a565..000000000
--- a/nixd/include/nixd/Parser/Parser.h
+++ /dev/null
@@ -1,63 +0,0 @@
-#pragma once
-
-#include "Parser.tab.h"
-
-#include "nixd/Parser/Require.h"
-
-#include <nix/nixexpr.hh>
-#include <nix/symbol-table.hh>
-
-#include <filesystem>
-#include <utility>
-
-namespace nixd {
-
-std::unique_ptr<ParseData> parse(char *Text, size_t Length,
-                                 nix::Pos::Origin Origin,
-                                 const nix::SourcePath &BasePath,
-                                 ParseState State);
-
-inline std::unique_ptr<ParseData> parse(char *Text, size_t Length,
-                                        nix::Pos::Origin Origin,
-                                        const nix::SourcePath &BasePath) {
-  nix::SymbolTable Symbols;
-  nix::PosTable Positions;
-  ParseState State{Symbols, Positions};
-  return parse(Text, Length, std::move(Origin), BasePath, State);
-}
-
-inline std::unique_ptr<ParseData> parse(std::string Text,
-                                        nix::Pos::Origin Origin,
-                                        const nix::SourcePath &BasePath) {
-  Text.append("\0\0", 2);
-  return parse(Text.data(), Text.length(), std::move(Origin), BasePath);
-}
-
-inline std::unique_ptr<ParseData> parse(std::string Text,
-                                        const std::string &Path) {
-  Text.append("\0\0", 2);
-  auto FSPath = std::filesystem::path(Path);
-  auto Origin = nix::CanonPath(FSPath.string());
-  auto BasePath = nix::CanonPath(FSPath.remove_filename().string());
-  return parse(Text.data(), Text.length(), std::move(Origin),
-               std::move(BasePath));
-}
-
-inline std::unique_ptr<ParseData> parse(char *Text, size_t Length,
-                                        nix::Pos::Origin Origin,
-                                        const nix::SourcePath &BasePath,
-                                        nix::EvalState &State) {
-  auto Data = parse(Text, Length, std::move(Origin), BasePath,
-                    ParseState{State.symbols, State.positions});
-  return Data;
-}
-
-inline std::unique_ptr<ParseData> parse(std::string Text,
-                                        nix::Pos::Origin Origin,
-                                        const nix::SourcePath &BasePath,
-                                        nix::EvalState &State) {
-  Text.append("\0\0", 2);
-  return parse(Text.data(), Text.length(), std::move(Origin), BasePath, State);
-}
-
-} // namespace nixd
diff --git a/nixd/include/nixd/Parser/Prologue.cpp b/nixd/include/nixd/Parser/Prologue.cpp
deleted file mode 100644
index 75da3986e..000000000
--- a/nixd/include/nixd/Parser/Prologue.cpp
+++ /dev/null
@@ -1,281 +0,0 @@
-
-#pragma once
-
-#include "Parser.tab.h"
-
-#include "Lexer.tab.h"
-
-#include "Provides.h"
-#include "Require.h"
-
-#include <nix/config.hh>
-#include <nix/nixexpr.hh>
-#include <nix/symbol-table.hh>
-
-YY_DECL;
-
-namespace nixd {
-
-using nix::absPath;
-using nix::AttrName;
-using nix::AttrPath;
-using nix::Error;
-using nix::ErrorInfo;
-using nix::evalSettings;
-using nix::experimentalFeatureSettings;
-using nix::Expr;
-using nix::Formal;
-using nix::Formals;
-using nix::getHome;
-using nix::hintfmt;
-using nix::noPos;
-using nix::Path;
-using nix::PosIdx;
-using nix::PosTable;
-using nix::SourcePath;
-using nix::Symbol;
-using nix::SymbolTable;
-using nix::Xp;
-
-using namespace nixd::nodes;
-
-static void dupAttr(ParseData &data, const AttrPath &attrPath, const PosIdx pos,
-                    const PosIdx prevPos) {
-  data.error.emplace_back(
-      nix::ErrorInfo{.msg = hintfmt("attribute '%1%' already defined at %2%",
-                                    showAttrPath(data.state.symbols, attrPath),
-                                    data.state.positions[prevPos]),
-                     .errPos = data.state.positions[pos]});
-}
-
-static void dupAttr(ParseData &data, Symbol attr, const PosIdx pos,
-                    const PosIdx prevPos) {
-  data.error.emplace_back(nix::ErrorInfo{
-      .msg = hintfmt("attribute '%1%' already defined at %2%",
-                     data.state.symbols[attr], data.state.positions[prevPos]),
-      .errPos = data.state.positions[pos]});
-}
-
-static void addAttr(nix::ExprAttrs *attrs, AttrPath &&attrPath, nix::Expr *e,
-                    const nix::PosIdx pos, ParseData &data) {
-  AttrPath::iterator i;
-  // All attrpaths have at least one attr
-  assert(!attrPath.empty());
-  // Checking attrPath validity.
-  // ===========================
-  for (i = attrPath.begin(); i + 1 < attrPath.end(); i++) {
-    if (i->symbol) {
-      ExprAttrs::AttrDefs::iterator j = attrs->attrs.find(i->symbol);
-      if (j != attrs->attrs.end()) {
-        if (!j->second.inherited) {
-          ExprAttrs *attrs2 = dynamic_cast<ExprAttrs *>(j->second.e);
-          if (!attrs2) {
-
-            dupAttr(data, attrPath, pos, j->second.pos);
-            return;
-          }
-          attrs = attrs2;
-        } else {
-
-          dupAttr(data, attrPath, pos, j->second.pos);
-          return;
-        }
-      } else {
-        ExprAttrs *nested = data.ctx.record(new ExprAttrs);
-        attrs->attrs[i->symbol] = ExprAttrs::AttrDef(nested, pos);
-        attrs = nested;
-      }
-    } else {
-      ExprAttrs *nested = data.ctx.record(new ExprAttrs);
-      attrs->dynamicAttrs.push_back(
-          ExprAttrs::DynamicAttrDef(i->expr, nested, pos));
-      attrs = nested;
-    }
-  }
-  // Expr insertion.
-  // ==========================
-  if (i->symbol) {
-    ExprAttrs::AttrDefs::iterator j = attrs->attrs.find(i->symbol);
-    if (j != attrs->attrs.end()) {
-      // This attr path is already defined. However, if both
-      // e and the expr pointed by the attr path are two attribute sets,
-      // we want to merge them.
-      // Otherwise, throw an error.
-      auto ae = dynamic_cast<ExprAttrs *>(e);
-      auto jAttrs = dynamic_cast<ExprAttrs *>(j->second.e);
-      if (jAttrs && ae) {
-        for (auto &ad : ae->attrs) {
-          auto j2 = jAttrs->attrs.find(ad.first);
-          if (j2 != jAttrs->attrs.end()) {
-            // Attr already defined in iAttrs, error.
-
-            dupAttr(data, ad.first, j2->second.pos, ad.second.pos);
-            return;
-          }
-          jAttrs->attrs.emplace(ad.first, ad.second);
-        }
-      } else {
-
-        dupAttr(data, attrPath, pos, j->second.pos);
-        return;
-      }
-    } else {
-      // This attr path is not defined. Let's create it.
-      attrs->attrs.emplace(i->symbol, ExprAttrs::AttrDef(e, pos));
-      e->setName(i->symbol);
-    }
-  } else {
-    attrs->dynamicAttrs.push_back(ExprAttrs::DynamicAttrDef(i->expr, e, pos));
-  }
-}
-
-static Formals *toFormals(ParseData &data, ParserFormals *formals,
-                          PosIdx pos = nix::noPos, Symbol arg = {}) {
-  std::sort(formals->formals.begin(), formals->formals.end(),
-            [](const auto &a, const auto &b) {
-              return std::tie(a.name, a.pos) < std::tie(b.name, b.pos);
-            });
-
-  std::optional<std::pair<Symbol, PosIdx>> duplicate;
-  for (size_t i = 0; i + 1 < formals->formals.size(); i++) {
-    if (formals->formals[i].name != formals->formals[i + 1].name)
-      continue;
-    std::pair thisDup{formals->formals[i].name, formals->formals[i + 1].pos};
-    duplicate = std::min(thisDup, duplicate.value_or(thisDup));
-  }
-  if (duplicate)
-    data.error.emplace_back(nix::ErrorInfo{
-        .msg = hintfmt("duplicate formal function argument '%1%'",
-                       data.state.symbols[duplicate->first]),
-        .errPos = data.state.positions[duplicate->second]});
-
-  Formals result;
-  result.ellipsis = formals->ellipsis;
-  result.formals = std::move(formals->formals);
-
-  if (arg && result.has(arg))
-    data.error.emplace_back(nix::ErrorInfo{
-        .msg = hintfmt("duplicate formal function argument '%1%'",
-                       data.state.symbols[arg]),
-        .errPos = data.state.positions[pos]});
-
-  return data.FsCtx.record(new Formals(std::move(result)));
-}
-
-static Expr *stripIndentation(
-    ParseData &data, const PosIdx pos, SymbolTable &symbols,
-    std::vector<std::pair<PosIdx, std::variant<Expr *, StringToken>>> &&es) {
-  if (es.empty())
-    return data.ctx.record(new ExprString(""));
-
-  /* Figure out the minimum indentation.  Note that by design
-     whitespace-only final lines are not taken into account.  (So
-     the " " in "\n ''" is ignored, but the " " in "\n foo''" is.) */
-  bool atStartOfLine = true; /* = seen only whitespace in the current line */
-  size_t minIndent = 1000000;
-  size_t curIndent = 0;
-  for (auto &[i_pos, i] : es) {
-    auto *str = std::get_if<StringToken>(&i);
-    if (!str || !str->hasIndentation) {
-      /* Anti-quotations and escaped characters end the current start-of-line
-       * whitespace. */
-      if (atStartOfLine) {
-        atStartOfLine = false;
-        if (curIndent < minIndent)
-          minIndent = curIndent;
-      }
-      continue;
-    }
-    for (size_t j = 0; j < str->l; ++j) {
-      if (atStartOfLine) {
-        if (str->p[j] == ' ')
-          curIndent++;
-        else if (str->p[j] == '\n') {
-          /* Empty line, doesn't influence minimum
-             indentation. */
-          curIndent = 0;
-        } else {
-          atStartOfLine = false;
-          if (curIndent < minIndent)
-            minIndent = curIndent;
-        }
-      } else if (str->p[j] == '\n') {
-        atStartOfLine = true;
-        curIndent = 0;
-      }
-    }
-  }
-
-  /* Strip spaces from each line. */
-  auto *es2 = new std::vector<std::pair<PosIdx, Expr *>>;
-  data.SPCtx.record(es2);
-  atStartOfLine = true;
-  size_t curDropped = 0;
-  size_t n = es.size();
-  auto i = es.begin();
-  const auto trimExpr = [&](Expr *e) {
-    atStartOfLine = false;
-    curDropped = 0;
-    es2->emplace_back(i->first, e);
-  };
-  const auto trimString = [&](const StringToken &t) {
-    std::string s2;
-    for (size_t j = 0; j < t.l; ++j) {
-      if (atStartOfLine) {
-        if (t.p[j] == ' ') {
-          if (curDropped++ >= minIndent)
-            s2 += t.p[j];
-        } else if (t.p[j] == '\n') {
-          curDropped = 0;
-          s2 += t.p[j];
-        } else {
-          atStartOfLine = false;
-          curDropped = 0;
-          s2 += t.p[j];
-        }
-      } else {
-        s2 += t.p[j];
-        if (t.p[j] == '\n')
-          atStartOfLine = true;
-      }
-    }
-
-    /* Remove the last line if it is empty and consists only of
-       spaces. */
-    if (n == 1) {
-      std::string::size_type p = s2.find_last_of('\n');
-      if (p != std::string::npos &&
-          s2.find_first_not_of(' ', p + 1) == std::string::npos)
-        s2 = std::string(s2, 0, p + 1);
-    }
-
-    es2->emplace_back(i->first, data.ctx.record(new ExprString(std::move(s2))));
-  };
-  for (; i != es.end(); ++i, --n) {
-    std::visit(nix::overloaded{trimExpr, trimString}, i->second);
-  }
-
-  /* If this is a single string, then don't do a concatenation. */
-  if (es2->size() == 1 && dynamic_cast<ExprString *>((*es2)[0].second)) {
-    auto *const result = (*es2)[0].second;
-    return result;
-  }
-  return data.ctx.record(new ExprConcatStrings(pos, true, es2));
-}
-
-} // namespace nixd
-
-using namespace nixd;
-
-#define CUR_POS makeCurPos(*yylocp, data)
-
-void yyerror(YYLTYPE *loc, yyscan_t scanner, ParseData *data,
-             const char *error) {
-  data->error.push_back(
-      {.msg = hintfmt(error),
-       .errPos = data->state.positions[makeCurPos(*loc, data)]});
-}
-
-template <class T> T *M(nixd::ParseData *data, T *node) {
-  return data->ctx.addNode(std::unique_ptr<T>(node));
-}
diff --git a/nixd/include/nixd/Parser/Provides.h b/nixd/include/nixd/Parser/Provides.h
deleted file mode 100644
index 748a76a5d..000000000
--- a/nixd/include/nixd/Parser/Provides.h
+++ /dev/null
@@ -1,17 +0,0 @@
-#pragma once
-
-#include "Parser.tab.h"
-
-#include <nix/nixexpr.hh>
-
-namespace nixd {
-
-static inline nix::PosIdx makeCurPos(const YYLTYPE &loc, ParseData *data) {
-  auto Res =
-      data->state.positions.add(data->origin, loc.first_line, loc.first_column);
-  data->end[Res] =
-      data->state.positions.add(data->origin, loc.last_line, loc.last_column);
-  return Res;
-}
-
-} // namespace nixd
diff --git a/nixd/include/nixd/Parser/Require.h b/nixd/include/nixd/Parser/Require.h
deleted file mode 100644
index 6f2c72e79..000000000
--- a/nixd/include/nixd/Parser/Require.h
+++ /dev/null
@@ -1,70 +0,0 @@
-#pragma once
-
-#include "nixd/Expr/Expr.h"
-#include "nixd/Expr/Nodes.h"
-
-#include <nix/error.hh>
-#include <nix/eval.hh>
-#include <nix/globals.hh>
-#include <nix/input-accessor.hh>
-#include <nix/nixexpr.hh>
-#include <nix/symbol-table.hh>
-#include <nix/types.hh>
-#include <nix/util.hh>
-
-#include <variant>
-
-// using C a struct allows us to avoid having to define the special
-// members that using string_view here would implicitly delete.
-struct StringToken {
-  const char *p;
-  size_t l;
-  bool hasIndentation;
-  operator std::string_view() const { return {p, l}; }
-};
-
-namespace nixd {
-
-struct ParserFormals {
-  std::vector<nix::Formal> formals;
-  bool ellipsis = false;
-};
-struct ParseState {
-  nix::SymbolTable &symbols;
-  nix::PosTable &positions;
-};
-
-struct ParseData {
-  using IndStringParts = std::vector<
-      std::pair<nix::PosIdx, std::variant<nix::Expr *, StringToken>>>;
-  using StringParts = std::vector<std::pair<nix::PosIdx, nix::Expr *>>;
-  using AttrNames = std::vector<nix::AttrName>;
-
-  std::unique_ptr<nix::SymbolTable> STable;
-  std::unique_ptr<nix::PosTable> PTable;
-
-  ParseState state;
-  nix::Expr *result;
-  nix::SourcePath basePath;
-  nix::PosTable::Origin origin;
-  std::vector<nix::ErrorInfo> error;
-  std::map<nix::PosIdx, nix::PosIdx> end;
-  std::map<const void *, nix::PosIdx> locations;
-
-  ASTContext ctx;
-
-  Context<ParserFormals> PFCtx;
-  Context<nix::Formal> FCtx;
-  Context<nix::Formals> FsCtx;
-  Context<nix::AttrPath> APCtx;
-
-  Context<AttrNames> ANCtx;
-  Context<StringParts> SPCtx;
-  Context<IndStringParts> ISPCtx;
-};
-
-} // namespace nixd
-
-#define YY_DECL                                                                \
-  int yylex(YYSTYPE *yylval_param, YYLTYPE *yylloc_param, yyscan_t yyscanner,  \
-            nixd::ParseData *data)
diff --git a/nixd/include/nixd/Lexer/Prologue.h b/nixd/include/nixd/Syntax/Lexer/Prologue.cpp
similarity index 93%
rename from nixd/include/nixd/Lexer/Prologue.h
rename to nixd/include/nixd/Syntax/Lexer/Prologue.cpp
index 7bfc2d049..37d42c873 100644
--- a/nixd/include/nixd/Lexer/Prologue.h
+++ b/nixd/include/nixd/Syntax/Lexer/Prologue.cpp
@@ -8,8 +8,6 @@
 
 #include "Parser.tab.h"
 
-#include "nixd/Parser/Provides.h"
-
 #include <nix/nixexpr.hh>
 
 using namespace nix;
@@ -48,7 +46,8 @@ static void adjustLoc(YYLTYPE *loc, const char *s, size_t len) {
 
 // we make use of the fact that the parser receives a private copy of the input
 // string and can munge around in it.
-static StringToken unescapeStr(SymbolTable &symbols, char *s, size_t length) {
+static nixd::syntax::StringToken unescapeStr(SymbolTable &symbols, char *s,
+                                             size_t length) {
   char *result = s;
   char *t = s;
   char c;
diff --git a/nixd/include/nixd/Syntax/Nodes.h b/nixd/include/nixd/Syntax/Nodes.h
new file mode 100644
index 000000000..ce1847357
--- /dev/null
+++ b/nixd/include/nixd/Syntax/Nodes.h
@@ -0,0 +1,64 @@
+/// FIXME: comment for this file.
+#pragma once
+
+#include <nix/nixexpr.hh>
+
+namespace nixd::syntax {
+
+/// Syntax nodes
+/// TODO: the comment
+struct Node {
+  nix::PosIdx Start;
+  nix::PosIdx End;
+};
+
+struct Function : Node {};
+
+struct Identifier : Node {};
+
+struct If : Node {};
+
+struct ExprOp : Node {};
+
+struct UnaryOp : ExprOp {};
+
+struct BinaryOp : ExprOp {};
+
+struct Apply : Node {};
+
+struct Select : Node {};
+
+struct Simple : Node {};
+
+struct Variable : Node {
+  Identifier ID;
+};
+
+struct Int : Node {};
+
+struct Float : Node {};
+
+struct StringParts : Node {};
+
+struct StringPartsInterpolated : Node {};
+
+struct List : Node {
+  std::vector<Select> Elems;
+};
+
+struct StringAttr : Node {};
+
+struct AttrPath : Node {};
+
+struct Formal : Node {
+  Identifier ID;
+  /// The default argument.
+  Node *Default;
+};
+
+struct Formals : Node {
+  std::vector<Formal> Formals;
+  bool Elipsis;
+};
+
+} // namespace nixd::syntax
diff --git a/nixd/include/nixd/Syntax/Parser/Prologue.cpp b/nixd/include/nixd/Syntax/Parser/Prologue.cpp
new file mode 100644
index 000000000..fa46192fc
--- /dev/null
+++ b/nixd/include/nixd/Syntax/Parser/Prologue.cpp
@@ -0,0 +1,10 @@
+#include "Parser.tab.h"
+
+#include "Lexer.tab.h"
+
+#include "nixd/Syntax/Nodes.h"
+
+YY_DECL;
+
+void yyerror(YYLTYPE *loc, yyscan_t scanner, nixd::syntax::ParseData *data,
+             const char *error) {}
diff --git a/nixd/include/nixd/Syntax/Parser/Require.h b/nixd/include/nixd/Syntax/Parser/Require.h
new file mode 100644
index 000000000..f5dd5d81b
--- /dev/null
+++ b/nixd/include/nixd/Syntax/Parser/Require.h
@@ -0,0 +1,38 @@
+#pragma once
+
+#include "nixd/Syntax/Nodes.h"
+
+#include <cstddef>
+#include <string_view>
+
+namespace nixd::syntax {
+
+/// For compatibility with official implementation
+/// The symbols & positions should be mapped to nix::EvalState::state
+/// Or owned by "ParseData"
+struct ParseState {
+  nix::SymbolTable &symbols;
+  nix::PosTable &positions;
+};
+
+struct ParseData {
+  ParseState state;
+};
+
+// Note: copied from
+// https://github.com/NixOS/nix/blob/b99fdcf8dbb38ec0be0e82f65d1d138ec9e89dda/src/libexpr/parser.y#L47C1-L54C3
+//
+// using C a struct allows us to avoid having to define the special
+// members that using string_view here would implicitly delete.
+struct StringToken {
+  const char *p;
+  size_t l;
+  bool hasIndentation;
+  operator std::string_view() const { return {p, l}; }
+};
+
+} // namespace nixd::syntax
+
+#define YY_DECL                                                                \
+  int yylex(YYSTYPE *yylval_param, YYLTYPE *yylloc_param, yyscan_t yyscanner,  \
+            nixd::syntax::ParseData *data)
diff --git a/nixd/lib/Syntax/Lexer.l b/nixd/lib/Syntax/Lexer.l
new file mode 100644
index 000000000..fbdc81934
--- /dev/null
+++ b/nixd/lib/Syntax/Lexer.l
@@ -0,0 +1,235 @@
+%option reentrant bison-bridge bison-locations
+%option noyywrap
+%option never-interactive
+%option stack
+%option nodefault
+%option nounput noyy_top_state
+
+
+%s DEFAULT
+%x STRING
+%x IND_STRING
+%x INPATH
+%x INPATH_SLASH
+%x PATH_START
+
+
+%{
+#include "nixd/Syntax/Lexer/Prologue.cpp"
+%}
+
+
+ANY         .|\n
+ID          [a-zA-Z\_][a-zA-Z0-9\_\'\-]*
+INT         [0-9]+
+FLOAT       (([1-9][0-9]*\.[0-9]*)|(0?\.[0-9]+))([Ee][+-]?[0-9]+)?
+PATH_CHAR   [a-zA-Z0-9\.\_\-\+]
+PATH        {PATH_CHAR}*(\/{PATH_CHAR}+)+\/?
+PATH_SEG    {PATH_CHAR}*\/
+HPATH       \~(\/{PATH_CHAR}+)+\/?
+HPATH_START \~\/
+SPATH       \<{PATH_CHAR}+(\/{PATH_CHAR}+)*\>
+URI         [a-zA-Z][a-zA-Z0-9\+\-\.]*\:[a-zA-Z0-9\%\/\?\:\@\&\=\+\$\,\-\_\.\!\~\*\']+
+
+
+%%
+
+
+if          { return IF; }
+then        { return THEN; }
+else        { return ELSE; }
+assert      { return ASSERT; }
+with        { return WITH; }
+let         { return LET; }
+in          { return IN; }
+rec         { return REC; }
+inherit     { return INHERIT; }
+or          { return OR_KW; }
+\.\.\.      { return ELLIPSIS; }
+
+\=\=        { return EQ; }
+\!\=        { return NEQ; }
+\<\=        { return LEQ; }
+\>\=        { return GEQ; }
+\&\&        { return AND; }
+\|\|        { return OR; }
+\-\>        { return IMPL; }
+\/\/        { return UPDATE; }
+\+\+        { return CONCAT; }
+
+{ID}        { yylval->ID = {yytext, (size_t) yyleng}; return ID; }
+{INT}       { errno = 0;
+              try {
+                  yylval->N = boost::lexical_cast<int64_t>(yytext);
+              } catch (const boost::bad_lexical_cast &) {
+                  // TODO: emit the error
+                  /*
+                  data->error.emplace_back(nix::ErrorInfo{
+                      .msg = hintfmt("invalid integer '%1%'", yytext),
+                      .errPos = data->state.positions[CUR_POS],
+                  });
+                  */
+                  yyterminate();
+              }
+              return INT;
+            }
+{FLOAT}     {
+              errno = 0;
+              yylval->NF = strtod(yytext, 0);
+              // TODO: emit the error
+              /*
+              if (errno != 0) {
+                  data->error.emplace_back(nix::ErrorInfo{
+                      .msg = hintfmt("invalid float '%1%'", yytext),
+                      .errPos = data->state.positions[CUR_POS],
+                  });
+                  yyterminate();
+              }
+              */
+              return FLOAT;
+            }
+
+\$\{        { PUSH_STATE(DEFAULT); return DOLLAR_CURLY; }
+
+\}          { /* State INITIAL only exists at the bottom of the stack and is
+                 used as a marker. DEFAULT replaces it everywhere else.
+                 Popping when in INITIAL state causes an empty stack exception,
+                 so don't */
+              if (YYSTATE != INITIAL)
+                POP_STATE();
+              return '}';
+            }
+\{          { PUSH_STATE(DEFAULT); return '{'; }
+
+\"          { PUSH_STATE(STRING); return '"'; }
+<STRING>([^\$\"\\]|\$[^\{\"\\]|\\{ANY}|\$\\{ANY})*\$/\" |
+<STRING>([^\$\"\\]|\$[^\{\"\\]|\\{ANY}|\$\\{ANY})+ {
+                /* It is impossible to match strings ending with '$' with one
+                   regex because trailing contexts are only valid at the end
+                   of a rule. (A sane but undocumented limitation.) */
+                yylval->STR = unescapeStr(data->state.symbols, yytext, yyleng);
+                return STR;
+              }
+<STRING>\$\{  { PUSH_STATE(DEFAULT); return DOLLAR_CURLY; }
+<STRING>\"    { POP_STATE(); return '"'; }
+<STRING>\$|\\|\$\\ {
+                /* This can only occur when we reach EOF, otherwise the above
+                   (...|\$[^\{\"\\]|\\.|\$\\.)+ would have triggered.
+                   This is technically invalid, but we leave the problem to the
+                   parser who fails with exact location. */
+                return EOF;
+              }
+
+\'\'(\ *\n)?     { PUSH_STATE(IND_STRING); return IND_STRING_OPEN; }
+<IND_STRING>([^\$\']|\$[^\{\']|\'[^\'\$])+ {
+                   yylval->STR = {yytext, (size_t) yyleng, true};
+                   return IND_STR;
+                 }
+<IND_STRING>\'\'\$ |
+<IND_STRING>\$   {
+                   yylval->STR = {"$", 1};
+                   return IND_STR;
+                 }
+<IND_STRING>\'\'\' {
+                   yylval->STR = {"''", 2};
+                   return IND_STR;
+                 }
+<IND_STRING>\'\'\\{ANY} {
+                   yylval->STR = unescapeStr(data->state.symbols, yytext + 2, yyleng - 2);
+                   return IND_STR;
+                 }
+<IND_STRING>\$\{ { PUSH_STATE(DEFAULT); return DOLLAR_CURLY; }
+<IND_STRING>\'\' { POP_STATE(); return IND_STRING_CLOSE; }
+<IND_STRING>\'   {
+                   yylval->STR = {"'", 1};
+                   return IND_STR;
+                 }
+
+{PATH_SEG}\$\{ |
+{HPATH_START}\$\{ {
+  PUSH_STATE(PATH_START);
+  yyless(0);
+  *yylloc = prev_yylloc;
+}
+
+<PATH_START>{PATH_SEG} {
+  POP_STATE();
+  PUSH_STATE(INPATH_SLASH);
+  yylval->PATH = {yytext, (size_t) yyleng};
+  return PATH;
+}
+
+<PATH_START>{HPATH_START} {
+  POP_STATE();
+  PUSH_STATE(INPATH_SLASH);
+  yylval->PATH = {yytext, (size_t) yyleng};
+  return HPATH;
+}
+
+{PATH} {
+  if (yytext[yyleng-1] == '/')
+    PUSH_STATE(INPATH_SLASH);
+  else
+    PUSH_STATE(INPATH);
+  yylval->PATH = {yytext, (size_t) yyleng};
+  return PATH;
+}
+{HPATH} {
+  if (yytext[yyleng-1] == '/')
+    PUSH_STATE(INPATH_SLASH);
+  else
+    PUSH_STATE(INPATH);
+  yylval->PATH = {yytext, (size_t) yyleng};
+  return HPATH;
+}
+
+<INPATH,INPATH_SLASH>\$\{ {
+  POP_STATE();
+  PUSH_STATE(INPATH);
+  PUSH_STATE(DEFAULT);
+  return DOLLAR_CURLY;
+}
+<INPATH,INPATH_SLASH>{PATH}|{PATH_SEG}|{PATH_CHAR}+ {
+  POP_STATE();
+  if (yytext[yyleng-1] == '/')
+      PUSH_STATE(INPATH_SLASH);
+  else
+      PUSH_STATE(INPATH);
+  yylval->STR = {yytext, (size_t) yyleng};
+  return STR;
+}
+<INPATH>{ANY} |
+<INPATH><<EOF>> {
+  /* if we encounter a non-path character we inform the parser that the path has
+     ended with a PATH_END token and re-parse this character in the default
+     context (it may be ')', ';', or something of that sort) */
+  POP_STATE();
+  yyless(0);
+  *yylloc = prev_yylloc;
+  return PATH_END;
+}
+
+<INPATH_SLASH>{ANY} |
+<INPATH_SLASH><<EOF>> {
+  /* data->error.emplace_back(nix::ErrorInfo{
+      .msg = hintfmt("path has a trailing slash"),
+      .errPos = data->state.positions[CUR_POS],
+  });
+  */
+  yyterminate();
+}
+
+{SPATH}     { yylval->PATH = {yytext, (size_t) yyleng}; return SPATH; }
+{URI}       { yylval->URI = {yytext, (size_t) yyleng}; return URI; }
+
+[ \t\r\n]+    /* eat up whitespace */
+\#[^\r\n]*    /* single-line comments */
+\/\*([^*]|\*+[^*/])*\*+\/  /* long comments */
+
+{ANY}       {
+              /* Don't return a negative number, as this will cause
+                 Bison to stop parsing without an error. */
+              return (unsigned char) yytext[0];
+            }
+
+%%
diff --git a/nixd/lib/Syntax/Parser.y b/nixd/lib/Syntax/Parser.y
new file mode 100644
index 000000000..7484ac03a
--- /dev/null
+++ b/nixd/lib/Syntax/Parser.y
@@ -0,0 +1,186 @@
+%glr-parser
+%define api.pure
+%locations
+%define parse.error verbose
+%defines
+/* %no-lines */
+%parse-param { void * scanner }
+%parse-param { nixd::syntax::ParseData * data }
+%lex-param { void * scanner }
+%lex-param { nixd::syntax::ParseData * data }
+
+%code requires {
+#include "nixd/Syntax/Parser/Require.h"
+}
+
+%{
+#include "nixd/Syntax/Parser/Prologue.cpp"
+%}
+
+%union {
+    nixd::syntax::Node *Node;
+    nixd::syntax::Identifier *Identifier;
+    nixd::syntax::If *If;
+
+    // Tokens
+    nixd::syntax::StringToken STR;
+    nixd::syntax::StringToken ID;
+    nixd::syntax::StringToken PATH;
+    nixd::syntax::StringToken URI;
+    nix::NixInt N;
+    nix::NixFloat NF;
+}
+
+
+%type <Node> start expr expr_function
+%type <Identifier> identifier
+%type <If>  expr_if
+%token <Identifier> ID
+%token <N> INT
+%token <NF> FLOAT
+%token <STR> STR IND_STR
+%token <PATH> PATH HPATH SPATH PATH_END
+%token <URI> URI
+/* %token <id> ID ATTRPATH
+%token <str> STR IND_STR
+%token <n> INT
+%token <nf> FLOAT
+%token <path> PATH HPATH SPATH PATH_END
+%token <uri> URI */
+%token IF THEN ELSE ASSERT WITH LET IN REC INHERIT EQ NEQ AND OR IMPL OR_KW
+%token DOLLAR_CURLY /* == ${ */
+%token IND_STRING_OPEN IND_STRING_CLOSE
+%token ELLIPSIS
+
+%right IMPL
+%left OR
+%left AND
+%nonassoc EQ NEQ
+%nonassoc '<' '>' LEQ GEQ
+%right UPDATE
+%left NOT
+%left '+' '-'
+%left '*' '/'
+%right CONCAT
+%nonassoc '?'
+%nonassoc NEGATE
+
+%%
+
+start: expr;
+
+expr: expr_function;
+
+expr_function
+  : identifier ':' expr_function {
+    // TODO
+  }
+  | '{' formals '}' ':' expr_function {
+    // TODO
+  }
+  | '{' formals '}' '@' identifier ':' expr_function {
+    // TODO
+  }
+  | ASSERT expr ';' expr_function {
+    // TODO
+  }
+  | WITH expr ';' expr_function {
+  }
+  | LET binds IN expr_function {
+  }
+  | expr_if
+  ;
+
+
+expr_if
+  : IF expr THEN expr ELSE expr { }
+  | expr_op
+  ;
+
+expr_op
+  : '!' expr_op %prec NOT
+  | '-' expr_op %prec NEGATE
+  | expr_op EQ expr_op
+  | expr_op NEQ expr_op
+  | expr_op '<' expr_op
+  | expr_op LEQ expr_op
+  | expr_op '>' expr_op
+  | expr_op GEQ expr_op
+  | expr_op AND expr_op
+  | expr_op OR expr_op
+  | expr_op IMPL expr_op
+  | expr_op UPDATE expr_op
+  | expr_op '?' attrpath
+  | expr_op '+' expr_op
+  | expr_op '-' expr_op
+  | expr_op '*' expr_op
+  | expr_op '/' expr_op
+  | expr_op CONCAT expr_op
+  | expr_app
+  ;
+
+expr_app
+  : expr_app expr_select
+  | expr_select
+  ;
+
+expr_select
+  : expr_simple '.' attrpath
+  | expr_simple '.' attrpath OR_KW expr_select
+  | expr_simple OR_KW
+  | expr_simple
+  ;
+
+
+expr_simple
+  : identifier
+  ;
+
+identifier
+  : ID
+  ;
+
+
+binds
+  : binds attrpath '=' expr ';'
+  | binds INHERIT attrs ';'
+  | binds INHERIT '(' expr ')' attrs ';'
+  |
+  ;
+
+attrs
+  : attrs attr
+  | attrs string_attr
+  |
+  ;
+
+attrpath
+  : attrpath '.' attr
+  | attrpath '.' string_attr
+  | attr
+  | string_attr
+  ;
+
+attr
+  : identifier
+  | OR_KW
+  ;
+
+
+string_attr
+  : DOLLAR_CURLY expr '}'
+  ;
+
+formals
+  : formal ',' formals
+  | formal
+  |
+  | ELLIPSIS
+  ;
+
+formal
+  : identifier
+  | identifier '?' expr
+  ;
+
+%%
diff --git a/nixd/lib/Syntax/meson.build b/nixd/lib/Syntax/meson.build
new file mode 100644
index 000000000..2ac1f6d3c
--- /dev/null
+++ b/nixd/lib/Syntax/meson.build
@@ -0,0 +1,38 @@
+#------------------------------------------------------------------------------#
+# Parser & Lexer stuff
+flex = find_program('flex')
+bison = find_program('bison')
+
+# Args are specified in:
+# https://github.com/NixOS/nix/blob/a1cf16563f681b5cb3026f2bbca629996ed36d86/src/libexpr/local.mk#L31
+
+lexer = custom_target('lexer'
+, input : [ 'Lexer.l' ]
+, output : [ '@BASENAME@.tab.cpp', '@BASENAME@.tab.h' ]
+, command : [ flex, '--outfile=@OUTPUT0@', '--header-file=@OUTPUT1@', '@INPUT@' ]
+)
+
+parser = custom_target('parser'
+, input : [ 'Parser.y' ]
+, output : [ '@BASENAME@.tab.cpp', '@BASENAME@.tab.h' ]
+, command : [ bison, '@INPUT@', '--defines=@OUTPUT1@', '--output=@OUTPUT0@' ]
+)
+
+#------------------------------------------------------------------------------#
+libnixdParserDeps = [ nix_all, nixdExpr ]
+
+libnixdParser = library('nixdParser'
+, lexer
+, parser
+, include_directories: nixd_inc
+, dependencies: libnixdParserDeps
+, install: true
+)
+
+nixdParser = declare_dependency( include_directories: nixd_inc
+                               , sources: [ lexer
+                                          , parser
+                                          ]
+                               , link_with: libnixdParser
+                               , dependencies: libnixdParserDeps
+                               )
diff --git a/nixd/lib/meson.build b/nixd/lib/meson.build
index 39df63d31..eb6bbadde 100644
--- a/nixd/lib/meson.build
+++ b/nixd/lib/meson.build
@@ -1,6 +1,7 @@
 subdir('Expr')
 subdir('Nix')
-subdir('Parser')
+subdir('Syntax')
+# subdir('Parser')
 subdir('AST')
 subdir('Support')
 subdir('Sema')