diff --git a/bin/bcoin b/bin/bcoin
index 0df74c54f..840958d7b 100755
--- a/bin/bcoin
+++ b/bin/bcoin
@@ -43,8 +43,8 @@ for arg in "$@"; do
     --daemon)
       daemon=1
     ;;
-    --spv)
-      cmd='spvnode'
+   --spv)
+        cmd='spvnode'
     ;;
   esac
 done
diff --git a/lib/blockchain/chain.js b/lib/blockchain/chain.js
index 9cd0a312f..38201fe8e 100644
--- a/lib/blockchain/chain.js
+++ b/lib/blockchain/chain.js
@@ -2006,16 +2006,18 @@ class Chain extends AsyncEmitter {
     if (this.options.checkpoints) {
       if (this.height < this.network.lastCheckpoint)
         return;
-    }
-
-    if (this.tip.time < util.now() - this.network.block.maxTipAge)
+    } else if (!this.options.neutrino &&
+      this.tip.time < util.now() - this.network.block.maxTipAge)
       return;
 
     if (!this.hasChainwork())
       return;
 
     this.synced = true;
-    this.emit('full');
+    if (this.options.neutrino)
+      this.emit('headersFull');
+    else
+      this.emit('full');
   }
 
   /**
@@ -2616,6 +2618,7 @@ class ChainOptions {
     this.compression = true;
 
     this.spv = false;
+    this.neutrino = false;
     this.bip91 = false;
     this.bip148 = false;
     this.prune = false;
@@ -2662,6 +2665,11 @@ class ChainOptions {
       this.spv = options.spv;
     }
 
+    if (options.neutrino != null) {
+      assert(typeof options.neutrino === 'boolean');
+      this.neutrino = options.neutrino;
+    }
+
     if (options.prefix != null) {
       assert(typeof options.prefix === 'string');
       this.prefix = options.prefix;
diff --git a/lib/net/peer.js b/lib/net/peer.js
index 2271e7896..764bf8fef 100644
--- a/lib/net/peer.js
+++ b/lib/net/peer.js
@@ -1449,12 +1449,18 @@ class Peer extends EventEmitter {
       if (!(this.services & services.NETWORK))
         throw new Error('Peer does not support network services.');
 
+      if (this.options.neutrino) {
+        if (!(this.services & services.NODE_COMPACT_FILTERS)) {
+          throw new Error('Peer does not support Compact Filters.');
+        }
+      }
+
       if (this.options.headers) {
         if (this.version < common.HEADERS_VERSION)
           throw new Error('Peer does not support getheaders.');
       }
 
-      if (this.options.spv) {
+      if (this.options.spv && !this.options.neutrino) {
         if (!(this.services & services.BLOOM))
           throw new Error('Peer does not support BIP37.');
 
@@ -2080,6 +2086,7 @@ class PeerOptions {
     this.agent = common.USER_AGENT;
     this.noRelay = false;
     this.spv = false;
+    this.neutrino = false;
     this.compact = false;
     this.headers = false;
     this.banScore = common.BAN_SCORE;
@@ -2143,6 +2150,11 @@ class PeerOptions {
       this.spv = options.spv;
     }
 
+    if (options.neutrino != null) {
+      assert(typeof options.neutrino === 'boolean');
+      this.neutrino = options.neutrino;
+    }
+
     if (options.compact != null) {
       assert(typeof options.compact === 'boolean');
       this.compact = options.compact;
diff --git a/lib/net/pool.js b/lib/net/pool.js
index 234b23bc2..af9d01133 100644
--- a/lib/net/pool.js
+++ b/lib/net/pool.js
@@ -79,6 +79,7 @@ class Pool extends EventEmitter {
     this.pendingRefill = null;
 
     this.checkpoints = false;
+    this.neutrino = false;
     this.headerChain = new List();
     this.headerNext = null;
     this.headerTip = null;
@@ -204,7 +205,7 @@ class Pool extends EventEmitter {
    */
 
   resetChain() {
-    if (!this.options.checkpoints)
+    if (!this.options.checkpoints && !this.options.neutrino)
       return;
 
     this.checkpoints = false;
@@ -213,7 +214,10 @@ class Pool extends EventEmitter {
     this.headerNext = null;
 
     const tip = this.chain.tip;
-
+    if (this.options.neutrino) {
+      this.headerChain.push(new HeaderEntry(tip.hash, tip.height));
+      return;
+    }
     if (tip.height < this.network.lastCheckpoint) {
       this.checkpoints = true;
       this.headerTip = this.getNextTip(tip.height);
@@ -650,7 +654,10 @@ class Pool extends EventEmitter {
       return;
 
     this.syncing = true;
-    this.resync(false);
+    if (this.options.neutrino) {
+      this.startHeadersSync();
+    } else
+      this.resync(false);
   }
 
   /**
@@ -704,6 +711,32 @@ class Pool extends EventEmitter {
     this.compactBlocks.clear();
   }
 
+  /**
+   * Start the headers sync using getHeaders messages.
+   * @private
+   * @return {Promise}
+   */
+
+  async startHeadersSync() {
+    if (!this.syncing)
+      return;
+    let locator;
+    try {
+      locator = await this.chain.getLocator();
+    } catch (e) {
+      this.emit('error', e);
+      return;
+    }
+
+    const peer = this.peers.load;
+    if (!peer) {
+      this.logger.info('No loader peer.');
+      return;
+    }
+    this.chain.synced = false;
+    peer.sendGetHeaders(locator);
+  }
+
   /**
    * Send a sync to each peer.
    * @private
@@ -814,7 +847,10 @@ class Pool extends EventEmitter {
 
     peer.syncing = true;
     peer.blockTime = Date.now();
-
+    if (this.options.neutrino) {
+      peer.sendGetHeaders(locator);
+      return true;
+    }
     if (this.checkpoints) {
       peer.sendGetHeaders(locator, this.headerTip.hash);
       return true;
@@ -2027,6 +2063,9 @@ class Pool extends EventEmitter {
     if (this.options.selfish)
       return;
 
+    if (this.options.neutrino)
+      return;
+
     if (this.chain.options.spv)
       return;
 
@@ -2139,7 +2178,8 @@ class Pool extends EventEmitter {
   async _handleHeaders(peer, packet) {
     const headers = packet.items;
 
-    if (!this.checkpoints)
+    if (!this.checkpoints && !this.options.neutrino)
+      // todo add support for checkpoints
       return;
 
     if (!this.syncing)
@@ -2185,7 +2225,8 @@ class Pool extends EventEmitter {
 
       node = new HeaderEntry(hash, height);
 
-      if (node.height === this.headerTip.height) {
+      if (!this.options.neutrino && node.height === this.headerTip.height) {
+        // todo add support for checkpoints
         if (!node.hash.equals(this.headerTip.hash)) {
           this.logger.warning(
             'Peer sent an invalid checkpoint (%s).',
@@ -2200,6 +2241,8 @@ class Pool extends EventEmitter {
         this.headerNext = node;
 
       this.headerChain.push(node);
+      if (this.options.neutrino)
+        await this._addBlock(peer, header, chainCommon.flags.VERIFY_POW);
     }
 
     this.logger.debug(
@@ -2219,7 +2262,12 @@ class Pool extends EventEmitter {
     }
 
     // Request more headers.
-    peer.sendGetHeaders([node.hash], this.headerTip.hash);
+    if (this.chain.synced)
+      return;
+    if (this.options.neutrino)
+      peer.sendGetHeaders([node.hash]);
+    else
+      peer.sendGetHeaders([node.hash], this.headerTip.hash);
   }
 
   /**
@@ -2293,7 +2341,7 @@ class Pool extends EventEmitter {
 
     const hash = block.hash();
 
-    if (!this.resolveBlock(peer, hash)) {
+    if (!this.options.neutrino && !this.resolveBlock(peer, hash)) {
       this.logger.warning(
         'Received unrequested block: %h (%s).',
         block.hash(), peer.hostname());
@@ -3690,6 +3738,7 @@ class PoolOptions {
     this.prefix = null;
     this.checkpoints = true;
     this.spv = false;
+    this.neutrino = false;
     this.bip37 = false;
     this.bip157 = false;
     this.listen = false;
@@ -3772,12 +3821,19 @@ class PoolOptions {
 
     if (options.spv != null) {
       assert(typeof options.spv === 'boolean');
-      assert(options.spv === this.chain.options.spv);
+      // assert(options.spv === this.chain.options.spv);
       this.spv = options.spv;
     } else {
       this.spv = this.chain.options.spv;
     }
 
+    if (options.neutrino != null) {
+      assert(typeof options.neutrino === 'boolean');
+      this.neutrino = options.neutrino;
+      assert(options.compact === false ||
+        options.compact === undefined, 'We cannot use compact blocks');
+    }
+
     if (options.bip37 != null) {
       assert(typeof options.bip37 === 'boolean');
       this.bip37 = options.bip37;
@@ -3953,6 +4009,12 @@ class PoolOptions {
       this.listen = false;
     }
 
+    if (this.neutrino) {
+      this.requiredServices |= common.services.NODE_COMPACT_FILTERS;
+      this.checkpoints = true;
+      this.compact = false;
+    }
+
     if (this.selfish) {
       this.services &= ~common.services.NETWORK;
       this.bip37 = false;
diff --git a/lib/node/neutrino.js b/lib/node/neutrino.js
new file mode 100644
index 000000000..3f693dc19
--- /dev/null
+++ b/lib/node/neutrino.js
@@ -0,0 +1,301 @@
+/*!
+ * neutrino.js - spv node for bcoin
+ * Copyright (c) 2023-2021, Shaswat Gupta (MIT License).
+ * https://github.com/bcoin-org/bcoin
+ */
+
+'use strict';
+
+const assert = require('bsert');
+const Chain = require('../blockchain/chain');
+const Pool = require('../net/pool');
+const Node = require('./node');
+const HTTP = require('./http');
+const RPC = require('./rpc');
+const blockstore = require('../blockstore');
+const FilterIndexer = require('../indexer/filterindexer');
+
+/**
+ * Neutrino Node
+ * Create a neutrino node which only maintains
+ * a chain, a pool, and an http server.
+ * @alias module:node.Neutrino
+ * @extends Node
+ */
+
+class Neutrino extends Node {
+  /**
+   * Create Neutrino node.
+   * @constructor
+   * @param {Object?} options
+   * @param {Buffer?} options.sslKey
+   * @param {Buffer?} options.sslCert
+   * @param {Number?} options.httpPort
+   * @param {String?} options.httpHost
+   */
+
+  constructor(options) {
+    super('bcoin', 'bcoin.conf', 'debug.log', options);
+
+    this.opened = false;
+
+    // SPV flag.
+    this.spv = false;
+    this.neutrino = true;
+
+    // Instantiate block storage.
+    this.blocks = blockstore.create({
+      network: this.network,
+      logger: this.logger,
+      prefix: this.config.prefix,
+      cacheSize: this.config.mb('block-cache-size'),
+      memory: this.memory,
+      spv: this.spv,
+      neutrino: this.neutrino
+    });
+
+    this.chain = new Chain({
+      blocks: this.blocks,
+      network: this.network,
+      logger: this.logger,
+      prefix: this.config.prefix,
+      memory: this.memory,
+      maxFiles: this.config.uint('max-files'),
+      cacheSize: this.config.mb('cache-size'),
+      entryCache: this.config.uint('entry-cache'),
+      forceFlags: this.config.bool('force-flags'),
+      checkpoints: this.config.bool('checkpoints'),
+      bip91: this.config.bool('bip91'),
+      bip148: this.config.bool('bip148'),
+      spv: true,
+      neutrino: this.neutrino
+    });
+
+    this.filterIndexers.set(
+      'BASIC',
+      new FilterIndexer({
+        network: this.network,
+        logger: this.logger,
+        blocks: this.blocks,
+        chain: this.chain,
+        memory: this.config.bool('memory'),
+        prefix: this.config.str('index-prefix', this.config.prefix),
+        filterType: 'BASIC'
+      })
+    );
+
+    this.pool = new Pool({
+      network: this.network,
+      logger: this.logger,
+      chain: this.chain,
+      prefix: this.config.prefix,
+      checkpoints: true,
+      proxy: this.config.str('proxy'),
+      onion: this.config.bool('onion'),
+      upnp: this.config.bool('upnp'),
+      seeds: this.config.array('seeds'),
+      nodes: this.config.array('nodes'),
+      only: this.config.array('only'),
+      maxOutbound: this.config.uint('max-outbound'),
+      createSocket: this.config.func('create-socket'),
+      memory: this.memory,
+      selfish: true,
+      listen: false,
+      neutrino: this.neutrino,
+      spv: this.spv
+    });
+
+    this.rpc = new RPC(this);
+
+    this.http = new HTTP({
+      network: this.network,
+      logger: this.logger,
+      node: this,
+      prefix: this.config.prefix,
+      ssl: this.config.bool('ssl'),
+      keyFile: this.config.path('ssl-key'),
+      certFile: this.config.path('ssl-cert'),
+      host: this.config.str('http-host'),
+      port: this.config.uint('http-port'),
+      apiKey: this.config.str('api-key'),
+      noAuth: this.config.bool('no-auth'),
+      cors: this.config.bool('cors')
+    });
+
+    this.init();
+  }
+
+  /**
+   * Initialize the node.
+   * @private
+   */
+
+  init() {
+    console.log('Initializing Neutrino Node.');
+    // Bind to errors
+    this.chain.on('error', err => this.error(err));
+    this.pool.on('error', err => this.error(err));
+
+    if (this.http)
+      this.http.on('error', err => this.error(err));
+
+    this.pool.on('tx', (tx) => {
+      this.emit('tx', tx);
+    });
+
+    this.chain.on('connect', async (entry, block) => {
+      this.emit('connect', entry, block);
+    });
+
+    this.chain.on('disconnect', (entry, block) => {
+      this.emit('disconnect', entry, block);
+    });
+
+    this.chain.on('reorganize', (tip, competitor) => {
+      this.emit('reorganize', tip, competitor);
+    });
+
+    this.chain.on('reset', (tip) => {
+      this.emit('reset', tip);
+    });
+
+    this.chain.on('headersFull', () => {
+      if (this.chain.height === 0)
+        return;
+      this.logger.info('Block Headers are fully synced');
+    });
+
+    this.loadPlugins();
+  }
+
+  /**
+   * Open the node and all its child objects,
+   * wait for the database to load.
+   * @returns {Promise}
+   */
+
+  async open() {
+    assert(!this.opened, 'Neutrino Node is already open.');
+    this.opened = true;
+
+    await this.handlePreopen();
+    await this.blocks.open();
+    await this.chain.open();
+    await this.pool.open();
+
+    await this.openPlugins();
+
+    await this.http.open();
+    await this.handleOpen();
+
+    this.logger.info('Node is loaded.');
+  }
+
+  /**
+   * Close the node, wait for the database to close.
+   * @returns {Promise}
+   */
+
+  async close() {
+    assert(this.opened, 'Neutrino Node is not open.');
+    this.opened = false;
+
+    await this.handlePreclose();
+    await this.http.close();
+
+    await this.closePlugins();
+
+    await this.pool.close();
+    await this.chain.close();
+    await this.handleClose();
+  }
+
+  /**
+   * Scan for any missed transactions.
+   * Note that this will replay the blockchain sync.
+   * @param {Number|Hash} start - Start block.
+   * @returns {Promise}
+   */
+
+  async scan(start) {
+    throw new Error('Not implemented.');
+  }
+
+  /**
+   * Broadcast a transaction (note that this will _not_ be verified
+   * by the mempool - use with care, lest you get banned from
+   * bitcoind nodes).
+   * @param {TX|Block} item
+   * @returns {Promise}
+   */
+
+  async broadcast(item) {
+    try {
+      await this.pool.broadcast(item);
+    } catch (e) {
+      this.emit('error', e);
+    }
+  }
+
+  /**
+   * Broadcast a transaction (note that this will _not_ be verified
+   * by the mempool - use with care, lest you get banned from
+   * bitcoind nodes).
+   * @param {TX} tx
+   * @returns {Promise}
+   */
+
+  sendTX(tx) {
+    return this.broadcast(tx);
+  }
+
+  /**
+   * Broadcast a transaction. Silence errors.
+   * @param {TX} tx
+   * @returns {Promise}
+   */
+
+  relay(tx) {
+    return this.broadcast(tx);
+  }
+
+  /**
+   * Connect to the network.
+   * @returns {Promise}
+   */
+
+  connect() {
+    return this.pool.connect();
+  }
+
+  /**
+   * Disconnect from the network.
+   * @returns {Promise}
+   */
+
+  disconnect() {
+    return this.pool.disconnect();
+  }
+
+  /**
+   * Start the blockchain sync.
+   */
+
+  startSync() {
+    return this.pool.startSync();
+  }
+
+  /**
+   * Stop syncing the blockchain.
+   */
+
+  stopSync() {
+    return this.pool.stopSync();
+  }
+}
+
+/*
+ * Expose
+ */
+
+module.exports = Neutrino;