diff --git a/clojure_fib/CHANGELOG.md b/clojure_fib/CHANGELOG.md
deleted file mode 100644
index 7274901..0000000
--- a/clojure_fib/CHANGELOG.md
+++ /dev/null
@@ -1,24 +0,0 @@
-# Change Log
-All notable changes to this project will be documented in this file. This change log follows the conventions of [keepachangelog.com](http://keepachangelog.com/).
-
-## [Unreleased]
-### Changed
-- Add a new arity to `make-widget-async` to provide a different widget shape.
-
-## [0.1.1] - 2022-04-11
-### Changed
-- Documentation on how to make the widgets.
-
-### Removed
-- `make-widget-sync` - we're all async, all the time.
-
-### Fixed
-- Fixed widget maker to keep working when daylight savings switches over.
-
-## 0.1.0 - 2022-04-11
-### Added
-- Files from the new template.
-- Widget maker public API - `make-widget-sync`.
-
-[Unreleased]: https://sourcehost.site/your-name/clojure_fib/compare/0.1.1...HEAD
-[0.1.1]: https://sourcehost.site/your-name/clojure_fib/compare/0.1.0...0.1.1
diff --git a/clojure_fib/README.md b/clojure_fib/README.md
deleted file mode 100644
index 68aeb70..0000000
--- a/clojure_fib/README.md
+++ /dev/null
@@ -1,44 +0,0 @@
-# clojure_fib
-
-FIXME: description
-
-## Installation
-
-Download from http://example.com/FIXME.
-
-## Usage
-
-FIXME: explanation
-
-    $ java -jar clojure_fib-0.1.0-standalone.jar [args]
-
-## Options
-
-FIXME: listing of options this app accepts.
-
-## Examples
-
-...
-
-### Bugs
-
-...
-
-### Any Other Sections
-### That You Think
-### Might be Useful
-
-## License
-
-Copyright © 2022 FIXME
-
-This program and the accompanying materials are made available under the
-terms of the Eclipse Public License 2.0 which is available at
-http://www.eclipse.org/legal/epl-2.0.
-
-This Source Code may also be made available under the following Secondary
-Licenses when the conditions for such availability set forth in the Eclipse
-Public License, v. 2.0 are satisfied: GNU General Public License as published by
-the Free Software Foundation, either version 2 of the License, or (at your
-option) any later version, with the GNU Classpath Exception which is available
-at https://www.gnu.org/software/classpath/license.html.
diff --git a/clojure_fib/doc/intro.md b/clojure_fib/doc/intro.md
deleted file mode 100644
index 5767df8..0000000
--- a/clojure_fib/doc/intro.md
+++ /dev/null
@@ -1,3 +0,0 @@
-# Introduction to clojure_fib
-
-TODO: write [great documentation](http://jacobian.org/writing/what-to-write/)
diff --git a/clojure_fib/test/clojure_fib/core_test.clj b/clojure_fib/test/clojure_fib/core_test.clj
deleted file mode 100644
index 7099911..0000000
--- a/clojure_fib/test/clojure_fib/core_test.clj
+++ /dev/null
@@ -1,7 +0,0 @@
-(ns clojure-fib.core-test
-  (:require [clojure.test :refer :all]
-            [clojure-fib.core :refer :all]))
-
-(deftest a-test
-  (testing "FIXME, I fail."
-    (is (= 0 1))))
diff --git a/debug_plans b/debug_plans
deleted file mode 100644
index ac2032d..0000000
--- a/debug_plans
+++ /dev/null
@@ -1,32 +0,0 @@
-
-
-
-st prints just code
-	done
-env prints env, number offset?
-	done-ish
-
-argument in variable?
-	?
-
-exit with ret value
-	done
-abort
-	done
-
-
-call on error
-	done for eval symbol lookup
-
-Speedup by off-by-default & rerun with debug on
-	done!
-
-
-later
-	u/downp moves
-	print cleanup
-		done!
-
-
-
-
diff --git a/psudocode.txt b/doc/psudocode.txt
similarity index 100%
rename from psudocode.txt
rename to doc/psudocode.txt
diff --git a/fib.c b/fib.c
deleted file mode 100644
index 7dd927b..0000000
--- a/fib.c
+++ /dev/null
@@ -1,14 +0,0 @@
-
-int fib(n) {
-	if (n == 0) {
-		return 1;
-	} else if (n == 1) {
-		return 1;
-	} else {
-		return fib(n-1) + fib(n-2);
-	}
-}
-int main(int argc, char **argv) {
-	printf("%d\n", fib(atoi(argv[1])));
-	return 0;
-}
diff --git a/fib_let.c b/fib_let.c
deleted file mode 100644
index 85ef649..0000000
--- a/fib_let.c
+++ /dev/null
@@ -1,16 +0,0 @@
-
-int fib(n) {
-	if (n == 0) {
-		return 1;
-	} else if (n == 1) {
-		return 1;
-	} else {
-		int r1 = fib(n-1);
-		int r2 = fib(n-2);
-		return r1 + r2;
-	}
-}
-int main(int argc, char **argv) {
-	printf("%d\n", fib(atoi(argv[1])));
-	return 0;
-}
diff --git a/fib_test/builtin_fib.kp b/fib_test/builtin_fib.kp
new file mode 100644
index 0000000..ec67f07
--- /dev/null
+++ b/fib_test/builtin_fib.kp
@@ -0,0 +1,36 @@
+
+((wrap (vau root_env (quote)
+((wrap (vau (let1)
+(let1 lambda (vau se (p b1) (wrap (eval (array vau p b1) se)))
+(let1 current-env (vau de () de)
+(let1 cons (lambda (h t) (concat (array h) t))
+(let1 Y (lambda (f3)
+    ((lambda (x1) (x1 x1))
+     (lambda (x2) (f3 (wrap (vau app_env (& y) (lapply (x2 x2) y app_env)))))))
+(let1 vY (lambda (f)
+    ((lambda (x3) (x3 x3))
+     (lambda (x4) (f (vau de1 (& y) (vapply (x4 x4) y de1))))))
+(let1 let (vY (lambda (recurse) (vau de2 (vs b) (cond (= (len vs) 0) (eval b de2)
+                                                     true           (vapply let1 (array (idx vs 0) (idx vs 1) (array recurse (slice vs 2 -1) b)) de2)))))
+ (let (
+         lcompose (lambda (g f) (lambda (& args) (lapply g (array (lapply f args)))))
+         rec-lambda (vau se (n p b) (eval (array Y (array lambda (array n) (array lambda p b))) se))
+
+         fib (rec-lambda fib (n) (cond (= 0 n)   1
+                                       (= 1 n)   1
+                                       true      (+ (fib (- n 1)) (fib (- n 2)))))
+
+         monad  (array 'write  1 "enter number to fact: " (vau (written code)
+                      (array 'read 0 60 (vau (data code)
+                            (array 'exit (builtin_fib (read-string data)))
+                      ))
+
+                ))
+
+ ) monad)
+; end of all lets
+))))))
+; impl of let1
+)) (vau de (s v b) (eval (array (array wrap (array vau (array s) b)) v) de)))
+; impl of quote
+)) (vau (x5) x5))
diff --git a/fib_test/builtin_fib.wasm b/fib_test/builtin_fib.wasm
new file mode 100644
index 0000000..b212ca0
Binary files /dev/null and b/fib_test/builtin_fib.wasm differ
diff --git a/clojure_fib/.gitignore b/fib_test/clojure_fib/.gitignore
similarity index 100%
rename from clojure_fib/.gitignore
rename to fib_test/clojure_fib/.gitignore
diff --git a/clojure_fib/LICENSE b/fib_test/clojure_fib/LICENSE
similarity index 100%
rename from clojure_fib/LICENSE
rename to fib_test/clojure_fib/LICENSE
diff --git a/clojure_fib/project.clj b/fib_test/clojure_fib/project.clj
similarity index 100%
rename from clojure_fib/project.clj
rename to fib_test/clojure_fib/project.clj
diff --git a/clojure_fib/src/clojure_fib/core.clj b/fib_test/clojure_fib/src/clojure_fib/core.clj
similarity index 100%
rename from clojure_fib/src/clojure_fib/core.clj
rename to fib_test/clojure_fib/src/clojure_fib/core.clj
diff --git a/fib_test/clojure_hi/.gitignore b/fib_test/clojure_hi/.gitignore
new file mode 100644
index 0000000..d956ab0
--- /dev/null
+++ b/fib_test/clojure_hi/.gitignore
@@ -0,0 +1,13 @@
+/target
+/classes
+/checkouts
+profiles.clj
+pom.xml
+pom.xml.asc
+*.jar
+*.class
+/.lein-*
+/.nrepl-port
+/.prepl-port
+.hgignore
+.hg/
diff --git a/fib_test/clojure_hi/LICENSE b/fib_test/clojure_hi/LICENSE
new file mode 100644
index 0000000..2315126
--- /dev/null
+++ b/fib_test/clojure_hi/LICENSE
@@ -0,0 +1,280 @@
+Eclipse Public License - v 2.0
+
+    THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+    PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION
+    OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.
+
+1. DEFINITIONS
+
+"Contribution" means:
+
+  a) in the case of the initial Contributor, the initial content
+     Distributed under this Agreement, and
+
+  b) in the case of each subsequent Contributor:
+     i) changes to the Program, and
+     ii) additions to the Program;
+  where such changes and/or additions to the Program originate from
+  and are Distributed by that particular Contributor. A Contribution
+  "originates" from a Contributor if it was added to the Program by
+  such Contributor itself or anyone acting on such Contributor's behalf.
+  Contributions do not include changes or additions to the Program that
+  are not Modified Works.
+
+"Contributor" means any person or entity that Distributes the Program.
+
+"Licensed Patents" mean patent claims licensable by a Contributor which
+are necessarily infringed by the use or sale of its Contribution alone
+or when combined with the Program.
+
+"Program" means the Contributions Distributed in accordance with this
+Agreement.
+
+"Recipient" means anyone who receives the Program under this Agreement
+or any Secondary License (as applicable), including Contributors.
+
+"Derivative Works" shall mean any work, whether in Source Code or other
+form, that is based on (or derived from) the Program and for which the
+editorial revisions, annotations, elaborations, or other modifications
+represent, as a whole, an original work of authorship.
+
+"Modified Works" shall mean any work in Source Code or other form that
+results from an addition to, deletion from, or modification of the
+contents of the Program, including, for purposes of clarity any new file
+in Source Code form that contains any contents of the Program. Modified
+Works shall not include works that contain only declarations,
+interfaces, types, classes, structures, or files of the Program solely
+in each case in order to link to, bind by name, or subclass the Program
+or Modified Works thereof.
+
+"Distribute" means the acts of a) distributing or b) making available
+in any manner that enables the transfer of a copy.
+
+"Source Code" means the form of a Program preferred for making
+modifications, including but not limited to software source code,
+documentation source, and configuration files.
+
+"Secondary License" means either the GNU General Public License,
+Version 2.0, or any later versions of that license, including any
+exceptions or additional permissions as identified by the initial
+Contributor.
+
+2. GRANT OF RIGHTS
+
+  a) Subject to the terms of this Agreement, each Contributor hereby
+  grants Recipient a non-exclusive, worldwide, royalty-free copyright
+  license to reproduce, prepare Derivative Works of, publicly display,
+  publicly perform, Distribute and sublicense the Contribution of such
+  Contributor, if any, and such Derivative Works.
+
+  b) Subject to the terms of this Agreement, each Contributor hereby
+  grants Recipient a non-exclusive, worldwide, royalty-free patent
+  license under Licensed Patents to make, use, sell, offer to sell,
+  import and otherwise transfer the Contribution of such Contributor,
+  if any, in Source Code or other form. This patent license shall
+  apply to the combination of the Contribution and the Program if, at
+  the time the Contribution is added by the Contributor, such addition
+  of the Contribution causes such combination to be covered by the
+  Licensed Patents. The patent license shall not apply to any other
+  combinations which include the Contribution. No hardware per se is
+  licensed hereunder.
+
+  c) Recipient understands that although each Contributor grants the
+  licenses to its Contributions set forth herein, no assurances are
+  provided by any Contributor that the Program does not infringe the
+  patent or other intellectual property rights of any other entity.
+  Each Contributor disclaims any liability to Recipient for claims
+  brought by any other entity based on infringement of intellectual
+  property rights or otherwise. As a condition to exercising the
+  rights and licenses granted hereunder, each Recipient hereby
+  assumes sole responsibility to secure any other intellectual
+  property rights needed, if any. For example, if a third party
+  patent license is required to allow Recipient to Distribute the
+  Program, it is Recipient's responsibility to acquire that license
+  before distributing the Program.
+
+  d) Each Contributor represents that to its knowledge it has
+  sufficient copyright rights in its Contribution, if any, to grant
+  the copyright license set forth in this Agreement.
+
+  e) Notwithstanding the terms of any Secondary License, no
+  Contributor makes additional grants to any Recipient (other than
+  those set forth in this Agreement) as a result of such Recipient's
+  receipt of the Program under the terms of a Secondary License
+  (if permitted under the terms of Section 3).
+
+3. REQUIREMENTS
+
+3.1 If a Contributor Distributes the Program in any form, then:
+
+  a) the Program must also be made available as Source Code, in
+  accordance with section 3.2, and the Contributor must accompany
+  the Program with a statement that the Source Code for the Program
+  is available under this Agreement, and informs Recipients how to
+  obtain it in a reasonable manner on or through a medium customarily
+  used for software exchange; and
+
+  b) the Contributor may Distribute the Program under a license
+  different than this Agreement, provided that such license:
+     i) effectively disclaims on behalf of all other Contributors all
+     warranties and conditions, express and implied, including
+     warranties or conditions of title and non-infringement, and
+     implied warranties or conditions of merchantability and fitness
+     for a particular purpose;
+
+     ii) effectively excludes on behalf of all other Contributors all
+     liability for damages, including direct, indirect, special,
+     incidental and consequential damages, such as lost profits;
+
+     iii) does not attempt to limit or alter the recipients' rights
+     in the Source Code under section 3.2; and
+
+     iv) requires any subsequent distribution of the Program by any
+     party to be under a license that satisfies the requirements
+     of this section 3.
+
+3.2 When the Program is Distributed as Source Code:
+
+  a) it must be made available under this Agreement, or if the
+  Program (i) is combined with other material in a separate file or
+  files made available under a Secondary License, and (ii) the initial
+  Contributor attached to the Source Code the notice described in
+  Exhibit A of this Agreement, then the Program may be made available
+  under the terms of such Secondary Licenses, and
+
+  b) a copy of this Agreement must be included with each copy of
+  the Program.
+
+3.3 Contributors may not remove or alter any copyright, patent,
+trademark, attribution notices, disclaimers of warranty, or limitations
+of liability ("notices") contained within the Program from any copy of
+the Program which they Distribute, provided that Contributors may add
+their own appropriate notices.
+
+4. COMMERCIAL DISTRIBUTION
+
+Commercial distributors of software may accept certain responsibilities
+with respect to end users, business partners and the like. While this
+license is intended to facilitate the commercial use of the Program,
+the Contributor who includes the Program in a commercial product
+offering should do so in a manner which does not create potential
+liability for other Contributors. Therefore, if a Contributor includes
+the Program in a commercial product offering, such Contributor
+("Commercial Contributor") hereby agrees to defend and indemnify every
+other Contributor ("Indemnified Contributor") against any losses,
+damages and costs (collectively "Losses") arising from claims, lawsuits
+and other legal actions brought by a third party against the Indemnified
+Contributor to the extent caused by the acts or omissions of such
+Commercial Contributor in connection with its distribution of the Program
+in a commercial product offering. The obligations in this section do not
+apply to any claims or Losses relating to any actual or alleged
+intellectual property infringement. In order to qualify, an Indemnified
+Contributor must: a) promptly notify the Commercial Contributor in
+writing of such claim, and b) allow the Commercial Contributor to control,
+and cooperate with the Commercial Contributor in, the defense and any
+related settlement negotiations. The Indemnified Contributor may
+participate in any such claim at its own expense.
+
+For example, a Contributor might include the Program in a commercial
+product offering, Product X. That Contributor is then a Commercial
+Contributor. If that Commercial Contributor then makes performance
+claims, or offers warranties related to Product X, those performance
+claims and warranties are such Commercial Contributor's responsibility
+alone. Under this section, the Commercial Contributor would have to
+defend claims against the other Contributors related to those performance
+claims and warranties, and if a court requires any other Contributor to
+pay any damages as a result, the Commercial Contributor must pay
+those damages.
+
+5. NO WARRANTY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT
+PERMITTED BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN "AS IS"
+BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR
+IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF
+TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR
+PURPOSE. Each Recipient is solely responsible for determining the
+appropriateness of using and distributing the Program and assumes all
+risks associated with its exercise of rights under this Agreement,
+including but not limited to the risks and costs of program errors,
+compliance with applicable laws, damage to or loss of data, programs
+or equipment, and unavailability or interruption of operations.
+
+6. DISCLAIMER OF LIABILITY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT
+PERMITTED BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS
+SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST
+PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE
+EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+7. GENERAL
+
+If any provision of this Agreement is invalid or unenforceable under
+applicable law, it shall not affect the validity or enforceability of
+the remainder of the terms of this Agreement, and without further
+action by the parties hereto, such provision shall be reformed to the
+minimum extent necessary to make such provision valid and enforceable.
+
+If Recipient institutes patent litigation against any entity
+(including a cross-claim or counterclaim in a lawsuit) alleging that the
+Program itself (excluding combinations of the Program with other software
+or hardware) infringes such Recipient's patent(s), then such Recipient's
+rights granted under Section 2(b) shall terminate as of the date such
+litigation is filed.
+
+All Recipient's rights under this Agreement shall terminate if it
+fails to comply with any of the material terms or conditions of this
+Agreement and does not cure such failure in a reasonable period of
+time after becoming aware of such noncompliance. If all Recipient's
+rights under this Agreement terminate, Recipient agrees to cease use
+and distribution of the Program as soon as reasonably practicable.
+However, Recipient's obligations under this Agreement and any licenses
+granted by Recipient relating to the Program shall continue and survive.
+
+Everyone is permitted to copy and distribute copies of this Agreement,
+but in order to avoid inconsistency the Agreement is copyrighted and
+may only be modified in the following manner. The Agreement Steward
+reserves the right to publish new versions (including revisions) of
+this Agreement from time to time. No one other than the Agreement
+Steward has the right to modify this Agreement. The Eclipse Foundation
+is the initial Agreement Steward. The Eclipse Foundation may assign the
+responsibility to serve as the Agreement Steward to a suitable separate
+entity. Each new version of the Agreement will be given a distinguishing
+version number. The Program (including Contributions) may always be
+Distributed subject to the version of the Agreement under which it was
+received. In addition, after a new version of the Agreement is published,
+Contributor may elect to Distribute the Program (including its
+Contributions) under the new version.
+
+Except as expressly stated in Sections 2(a) and 2(b) above, Recipient
+receives no rights or licenses to the intellectual property of any
+Contributor under this Agreement, whether expressly, by implication,
+estoppel or otherwise. All rights in the Program not expressly granted
+under this Agreement are reserved. Nothing in this Agreement is intended
+to be enforceable by any entity that is not a Contributor or Recipient.
+No third-party beneficiary rights are created under this Agreement.
+
+Exhibit A - Form of Secondary Licenses Notice
+
+"This Source Code may also be made available under the following
+Secondary Licenses when the conditions for such availability set forth
+in the Eclipse Public License, v. 2.0 are satisfied: GNU General Public
+License as published by the Free Software Foundation, either version 2
+of the License, or (at your option) any later version, with the GNU
+Classpath Exception which is available at
+https://www.gnu.org/software/classpath/license.html."
+
+  Simply including a copy of this Agreement, including this Exhibit A
+  is not sufficient to license the Source Code under Secondary Licenses.
+
+  If it is not possible or desirable to put the notice in a particular
+  file, then You may include the notice in a location (such as a LICENSE
+  file in a relevant directory) where a recipient would be likely to
+  look for such a notice.
+
+  You may add additional accurate notices of copyright ownership.
diff --git a/fib_test/clojure_hi/project.clj b/fib_test/clojure_hi/project.clj
new file mode 100644
index 0000000..f8839d5
--- /dev/null
+++ b/fib_test/clojure_hi/project.clj
@@ -0,0 +1,10 @@
+(defproject clojure_hi "0.1.0-SNAPSHOT"
+  :description "FIXME: write description"
+  :url "http://example.com/FIXME"
+  :license {:name "EPL-2.0 OR GPL-2.0-or-later WITH Classpath-exception-2.0"
+            :url "https://www.eclipse.org/legal/epl-2.0/"}
+  :dependencies [[org.clojure/clojure "1.10.3"]]
+  :main ^:skip-aot clojure-hi.core
+  :target-path "target/%s"
+  :profiles {:uberjar {:aot :all
+                       :jvm-opts ["-Dclojure.compiler.direct-linking=true"]}})
diff --git a/fib_test/clojure_hi/src/clojure_hi/core.clj b/fib_test/clojure_hi/src/clojure_hi/core.clj
new file mode 100644
index 0000000..7f1b1b4
--- /dev/null
+++ b/fib_test/clojure_hi/src/clojure_hi/core.clj
@@ -0,0 +1,7 @@
+(ns clojure-hi.core
+  (:gen-class))
+
+(defn -main
+  "I don't do a whole lot ... yet."
+  [& args]
+  (println "Hello, World!"))
diff --git a/fib.kp b/fib_test/fib.kp
similarity index 100%
rename from fib.kp
rename to fib_test/fib.kp
diff --git a/fib.py b/fib_test/fib.py
similarity index 100%
rename from fib.py
rename to fib_test/fib.py
diff --git a/fib.scm b/fib_test/fib.scm
similarity index 100%
rename from fib.scm
rename to fib_test/fib.scm
diff --git a/fib2.kp b/fib_test/fib2.kp
similarity index 100%
rename from fib2.kp
rename to fib_test/fib2.kp
diff --git a/fib_test/fib_compiled.wasm b/fib_test/fib_compiled.wasm
new file mode 100644
index 0000000..de2b356
Binary files /dev/null and b/fib_test/fib_compiled.wasm differ
diff --git a/fib_test/fib_compiled_let.wasm b/fib_test/fib_compiled_let.wasm
new file mode 100644
index 0000000..0adda6c
Binary files /dev/null and b/fib_test/fib_compiled_let.wasm differ
diff --git a/fib_test/fib_compiled_manual.wasm b/fib_test/fib_compiled_manual.wasm
new file mode 100644
index 0000000..136d42b
Binary files /dev/null and b/fib_test/fib_compiled_manual.wasm differ
diff --git a/fib_test/fib_interpreted.wasm b/fib_test/fib_interpreted.wasm
new file mode 100644
index 0000000..c9e4708
Binary files /dev/null and b/fib_test/fib_interpreted.wasm differ
diff --git a/fib_test/fib_interpreted_let.wasm b/fib_test/fib_interpreted_let.wasm
new file mode 100644
index 0000000..1c7133f
Binary files /dev/null and b/fib_test/fib_interpreted_let.wasm differ
diff --git a/fib_let.kp b/fib_test/fib_let.kp
similarity index 100%
rename from fib_let.kp
rename to fib_test/fib_let.kp
diff --git a/fib_let.py b/fib_test/fib_let.py
similarity index 100%
rename from fib_let.py
rename to fib_test/fib_let.py
diff --git a/fib_let.scm b/fib_test/fib_let.scm
similarity index 100%
rename from fib_let.scm
rename to fib_test/fib_let.scm
diff --git a/fib_test/fib_tests.sh b/fib_test/fib_tests.sh
new file mode 100755
index 0000000..3dce40b
--- /dev/null
+++ b/fib_test/fib_tests.sh
@@ -0,0 +1,43 @@
+#!/usr/bin/env bash
+
+NUMBER=30
+
+touch csc_out.wasm && rm csc_out.wasm && scheme --script ../partial_eval.scm fib.kp
+mv csc_out.wasm fib_compiled.wasm
+touch csc_out.wasm && rm csc_out.wasm && scheme --script ../partial_eval.scm fib_let.kp
+mv csc_out.wasm fib_compiled_let.wasm
+
+touch csc_out.wasm && rm csc_out.wasm && scheme --script ../partial_eval.scm fib.kp no_compile
+mv csc_out.wasm fib_interpreted.wasm
+touch csc_out.wasm && rm csc_out.wasm && scheme --script ../partial_eval.scm fib_let.kp no_compile
+mv csc_out.wasm fib_interpreted_let.wasm
+
+touch csc_out.wasm && rm csc_out.wasm && scheme --script ../partial_eval.scm fib2.kp
+mv csc_out.wasm fib_compiled_manual.wasm
+touch csc_out.wasm && rm csc_out.wasm && scheme --script ../partial_eval.scm builtin_fib.kp
+mv csc_out.wasm builtin_fib.wasm
+
+pushd rust_fib
+cargo build --target=wasm32-wasi
+cargo build --release --target=wasm32-wasi
+cargo build
+cargo build --release
+popd
+
+pushd clojure_fib
+lein uberjar
+popd
+
+pushd clojure_hi
+lein uberjar
+popd
+
+hyperfine --warmup 2 --export-markdown table.md \
+	      'echo '$NUMBER' | wasmtime ./fib_compiled.wasm' 'echo '$NUMBER' | wasmtime ./fib_compiled_let.wasm' \
+		  'echo '$NUMBER' | wasmtime ./builtin_fib.wasm'  'echo '$NUMBER' | wasmtime ./fib_compiled_manual.wasm' \
+          "scheme --script ./fib.scm $NUMBER" "scheme --script ./fib_let.scm $NUMBER" \
+          "python3 ./fib.py $NUMBER" "python3 ./fib_let.py $NUMBER" \
+          'echo '$NUMBER' | wasmtime ./rust_fib/target/wasm32-wasi/debug/rust_let.wasm' 'echo '$NUMBER' | wasmtime ./rust_fib/target/wasm32-wasi/release/rust_let.wasm' \
+          "echo $NUMBER | java -jar ./clojure_fib/target/uberjar/clojure_fib-0.1.0-SNAPSHOT-standalone.jar" "echo $NUMBER | java -jar ./clojure_hi/target/uberjar/clojure_hi-0.1.0-SNAPSHOT-standalone.jar" \
+	      'echo '$NUMBER' | wasmtime ./fib_interpreted.wasm' 'echo '$NUMBER' | wasmtime ./fib_interpreted_let.wasm' \
+		  #end
diff --git a/rust_fib/Cargo.lock b/fib_test/rust_fib/Cargo.lock
similarity index 100%
rename from rust_fib/Cargo.lock
rename to fib_test/rust_fib/Cargo.lock
diff --git a/rust_fib/Cargo.toml b/fib_test/rust_fib/Cargo.toml
similarity index 100%
rename from rust_fib/Cargo.toml
rename to fib_test/rust_fib/Cargo.toml
diff --git a/rust_fib/src/main.rs b/fib_test/rust_fib/src/main.rs
similarity index 100%
rename from rust_fib/src/main.rs
rename to fib_test/rust_fib/src/main.rs
diff --git a/fib_test/table.md b/fib_test/table.md
new file mode 100644
index 0000000..0c96a31
--- /dev/null
+++ b/fib_test/table.md
@@ -0,0 +1,16 @@
+| Command | Mean [ms] | Min [ms] | Max [ms] | Relative |
+|:---|---:|---:|---:|---:|
+| `echo 30 \| wasmtime ./fib_compiled.wasm` | 104.2 ± 1.7 | 102.3 | 109.5 | 8.43 ± 0.46 |
+| `echo 30 \| wasmtime ./fib_compiled_let.wasm` | 138.2 ± 1.6 | 134.9 | 141.0 | 11.19 ± 0.59 |
+| `echo 30 \| wasmtime ./builtin_fib.wasm` | 12.4 ± 0.6 | 10.9 | 15.8 | 1.00 |
+| `echo 30 \| wasmtime ./fib_compiled_manual.wasm` | 299.3 ± 2.2 | 296.5 | 302.5 | 24.23 ± 1.27 |
+| `scheme --script ./fib.scm 30` | 53.6 ± 1.1 | 52.4 | 59.2 | 4.34 ± 0.24 |
+| `scheme --script ./fib_let.scm 30` | 53.7 ± 0.7 | 52.7 | 55.2 | 4.35 ± 0.23 |
+| `python3 ./fib.py 30` | 288.4 ± 3.1 | 283.6 | 292.7 | 23.34 ± 1.23 |
+| `python3 ./fib_let.py 30` | 303.4 ± 1.3 | 300.6 | 304.9 | 24.56 ± 1.27 |
+| `echo 30 \| wasmtime ./rust_fib/target/wasm32-wasi/debug/rust_let.wasm` | 30.0 ± 0.6 | 28.6 | 31.7 | 2.43 ± 0.14 |
+| `echo 30 \| wasmtime ./rust_fib/target/wasm32-wasi/release/rust_let.wasm` | 18.9 ± 0.5 | 17.7 | 20.1 | 1.53 ± 0.09 |
+| `echo 30 \| java -jar ./clojure_fib/target/uberjar/clojure_fib-0.1.0-SNAPSHOT-standalone.jar` | 691.4 ± 13.8 | 674.5 | 721.1 | 55.97 ± 3.10 |
+| `echo 30 \| java -jar ./clojure_hi/target/uberjar/clojure_hi-0.1.0-SNAPSHOT-standalone.jar` | 658.8 ± 19.1 | 639.7 | 699.9 | 53.33 ± 3.16 |
+| `echo 30 \| wasmtime ./fib_interpreted.wasm` | 11335.6 ± 65.1 | 11258.2 | 11479.3 | 917.63 ± 47.75 |
+| `echo 30 \| wasmtime ./fib_interpreted_let.wasm` | 31732.1 ± 161.9 | 31510.3 | 32067.4 | 2568.76 ± 133.49 |
diff --git a/fib_tests.sh b/fib_tests.sh
deleted file mode 100755
index 0845f6a..0000000
--- a/fib_tests.sh
+++ /dev/null
@@ -1,135 +0,0 @@
-#!/usr/bin/env bash
-
-NUMBER=30
-#NUMBER=25
-
-touch csc_out.wasm && rm csc_out.wasm && scheme --script ./partial_eval.scm fib.kp
-mv csc_out.wasm fib_compiled.wasm
-touch csc_out.wasm && rm csc_out.wasm && scheme --script ./partial_eval.scm fib_let.kp
-mv csc_out.wasm fib_compiled_let.wasm
-
-touch csc_out.wasm && rm csc_out.wasm && scheme --script ./partial_eval.scm fib.kp no_compile
-mv csc_out.wasm fib_interpreted.wasm
-touch csc_out.wasm && rm csc_out.wasm && scheme --script ./partial_eval.scm fib_let.kp no_compile
-mv csc_out.wasm fib_interpreted_let.wasm
-
-touch csc_out.wasm && rm csc_out.wasm && scheme --script ./partial_eval.scm fib2.kp
-mv csc_out.wasm fib_compiled_manual.wasm
-touch csc_out.wasm && rm csc_out.wasm && scheme --script ./partial_eval.scm builtin_fib.kp
-mv csc_out.wasm builtin_fib.wasm
-
-pushd rust_fib
-cargo build --target=wasm32-wasi
-cargo build --release --target=wasm32-wasi
-cargo build
-cargo build --release
-popd
-
-#pushd rust_let
-#cargo build --target=wasm32-wasi
-#cargo build --release --target=wasm32-wasi
-#cargo build
-#cargo build --release
-#popd
-#
-#pushd clojure_fib
-#lein uberjar
-#popd
-#
-#pushd clojure_hi
-#lein uberjar
-#popd
-
-#clang-11 fib.c -o c_fib
-#clang-11 fib_let.c -o c_fib_let
-
-
-hyperfine --warmup 2 --export-markdown table.md \
-	      'echo '$NUMBER' | wasmtime ./fib_compiled.wasm' 'echo '$NUMBER' | wasmtime ./fib_compiled_let.wasm' \
-		  'echo '$NUMBER' | wasmtime ./builtin_fib.wasm'  'echo '$NUMBER' | wasmtime ./fib_compiled_manual.wasm' \
-          "scheme --script ./fib.scm $NUMBER" "scheme --script ./fib_let.scm $NUMBER" \
-          "python3 ./fib.py $NUMBER" "python3 ./fib_let.py $NUMBER" \
-          'echo '$NUMBER' | wasmtime ./rust_fib/target/wasm32-wasi/debug/rust_let.wasm' 'echo '$NUMBER' | wasmtime ./rust_fib/target/wasm32-wasi/release/rust_let.wasm' \
-
-          #'echo '$NUMBER' | wasmtime ./rust_fib/target/wasm32-wasi/debug/rust_let.wasm' 'echo '$NUMBER' | wasmtime ./rust_fib/target/wasm32-wasi/release/rust_let.wasm' \
-          #'echo '$NUMBER' | ./rust_fib/target/debug/rust_let' 'echo '$NUMBER' | ./rust_fib/target/release/rust_let' \
-	      #'echo '$NUMBER' | wasmtime ./fib_interpreted.wasm' 'echo '$NUMBER' | wasmtime ./fib_interpreted_let.wasm' \
-          #"echo $NUMBER | java -jar ./clojure_fib/target/uberjar/clojure_fib-0.1.0-SNAPSHOT-standalone.jar" "echo $NUMBER | java -jar ./clojure_hi/target/uberjar/clojure_hi-0.1.0-SNAPSHOT-standalone.jar"
-
-          #"./c_fib $NUMBER" "./c_fib_let $NUMBER" \
-
-exit
-
-#touch csc_out.wasm && rm csc_out.wasm && scheme --script ./partial_eval.scm fib.kp                && time perf record -k mono wasmtime --jitdump ./csc_out.wasm
-#exit
-
-echo "Compile Straight"
-#touch csc_out.wasm && rm csc_out.wasm && scheme --script ./partial_eval.scm fib.kp                && time echo $NUMBER | wasm3 ./csc_out.wasm
-touch csc_out.wasm && rm csc_out.wasm && scheme --script ./partial_eval.scm fib.kp                && time echo $NUMBER | wasmtime ./csc_out.wasm
-#cp csc_out.wasm comp_fib_dyn.wasm
-
-echo "Compile Straight 2"
-#touch csc_out.wasm && rm csc_out.wasm && scheme --script ./partial_eval.scm fib.kp                && time echo $NUMBER | wasm3 ./csc_out.wasm
-touch csc_out.wasm && rm csc_out.wasm && scheme --script ./partial_eval.scm fib2.kp                && time echo $NUMBER | wasmtime ./csc_out.wasm
-
-echo "Compile Builtin"
-touch csc_out.wasm && rm csc_out.wasm && scheme --script ./partial_eval.scm builtin_fib.kp         && time echo $NUMBER | wasmtime ./csc_out.wasm
-
-echo "Interpret Straight"
-#touch csc_out.wasm && rm csc_out.wasm && scheme --script ./partial_eval.scm fib.kp no_compile     && time echo $NUMBER | wasm3 ./csc_out.wasm
-touch csc_out.wasm && rm csc_out.wasm && scheme --script ./partial_eval.scm fib.kp no_compile     && time echo $NUMBER | wasmtime ./csc_out.wasm
-
-echo "Compile Let"
-#touch csc_out.wasm && rm csc_out.wasm && scheme --script ./partial_eval.scm fib_let.kp            && time echo $NUMBER | wasm3 ./csc_out.wasm
-touch csc_out.wasm && rm csc_out.wasm && scheme --script ./partial_eval.scm fib_let.kp            && time echo $NUMBER | wasmtime ./csc_out.wasm
-
-echo "Interpret Let"
-#touch csc_out.wasm && rm csc_out.wasm && scheme --script ./partial_eval.scm fib_let.kp no_compile && time echo $NUMBER | wasm3 ./csc_out.wasm
-touch csc_out.wasm && rm csc_out.wasm && scheme --script ./partial_eval.scm fib_let.kp no_compile && time echo $NUMBER | wasmtime ./csc_out.wasm
-
-echo "Python"
-time python3 ./fib.py $NUMBER
-
-echo "Rust Wasm Debug"
-pushd rust_fib
-cargo build --target=wasm32-wasi && time echo $NUMBER | wasmtime target/wasm32-wasi/debug/rust_let.wasm
-popd
-
-echo "Rust Wasm Release"
-pushd rust_fib
-cargo build --release --target=wasm32-wasi && time echo $NUMBER | wasmtime target/wasm32-wasi/release/rust_let.wasm
-popd
-
-echo "Rust x86 Debug"
-pushd rust_fib
-cargo build && time echo $NUMBER | ./target/debug/rust_let
-popd
-
-echo "Rust x86 Release"
-pushd rust_fib
-cargo build --release && time echo $NUMBER | ./target/release/rust_let
-popd
-
-echo "Clojure"
-pushd clojure_fib
-lein uberjar && time echo $NUMBER | time java -jar target/uberjar/clojure_fib-0.1.0-SNAPSHOT-standalone.jar
-popd
-
-echo "Chez Scheme"
-time scheme --script ./fib.scm $NUMBER
-
-echo "Chez Scheme Let"
-time scheme --script ./fib_let.scm $NUMBER
-
-echo "Python"
-time python3 ./fib.py $NUMBER
-
-echo "Python Let"
-time python3 ./fib_let.py $NUMBER
-
-echo "C"
-clang-11 fib.c -o fib && time ./fib $NUMBER
-
-echo "C let"
-clang-11 fib_let.c -o fib_let && time ./fib_let $NUMBER
-
diff --git a/foldl_demo.kp b/foldl_demo.kp
deleted file mode 100644
index ca48b8f..0000000
--- a/foldl_demo.kp
+++ /dev/null
@@ -1,53 +0,0 @@
-((wrap (vau root_env (quote)
-((wrap (vau (let1)
-(let1 lambda (vau se (p b1) (wrap (eval (array vau p b1) se)))
-(let1 current-env (vau de () de)
-(let1 cons (lambda (h t) (concat (array h) t))
-(let1 Y (lambda (f3)
-    ((lambda (x1) (x1 x1))
-     (lambda (x2) (f3 (lambda (& y) (lapply (x2 x2) y))))))
-(let1 vY (lambda (f)
-    ((lambda (x3) (x3 x3))
-     (lambda (x4) (f (vau de1 (& y) (vapply (x4 x4) y de1))))))
-(let1 let (vY (lambda (recurse) (vau de2 (vs b) (cond (= (len vs) 0) (eval b de2)
-                                                     true           (vapply let1 (array (idx vs 0) (idx vs 1) (array recurse (slice vs 2 -1) b)) de2)))))
- (let (
-         rec-lambda (vau se (n p b) (eval (array Y (array lambda (array n) (array lambda p b))) se))
-         if (vau de (con than & else) (cond (eval con de) (eval than de)
-                                            (> (len else) 0) (eval (idx else 0) de)
-                                            true false))
-         map (lambda (f5 l5)
-             ; now maybe errors on can't find helper?
-             (let (helper (rec-lambda recurse (f4 l4 n4 i4)
-                                             (cond (= i4 (len l4))         n4
-                                                   (<= i4 (- (len l4) 4))  (recurse f4 l4 (concat n4 (array
-                                                                                                 (f4 (idx l4 (+ i4 0)))
-                                                                                                 (f4 (idx l4 (+ i4 1)))
-                                                                                                 (f4 (idx l4 (+ i4 2)))
-                                                                                                 (f4 (idx l4 (+ i4 3)))
-                                                                                                 )) (+ i4 4))
-                                                   true                  (recurse f4 l4 (concat n4 (array (f4 (idx l4 i4)))) (+ i4 1)))))
-                  (helper f5 l5 (array) 0)))
-        and (let (macro_helper (rec-lambda recurse (bs i) (cond (= i       (len bs)) true
-                                                                (= (+ 1 i) (len bs)) (idx bs i)
-                                                                true       (array let (array 'tmp (idx bs i)) (array if 'tmp (recurse bs (+ i 1)) 'tmp)))))
-                 (vau se (& bs) (eval (macro_helper bs 0) se)))
-
-        foldl (let (helper (rec-lambda recurse (f z vs i) (if (= i (len (idx vs 0))) z
-                                                                           (recurse f (lapply f (cons z (map (lambda (x) (idx x i)) vs))) vs (+ i 1)))))
-                   (lambda (f z & vs) (helper f z vs 0)))
-        zip (lambda (& xs) (lapply foldl (concat (array (lambda (a & ys) (cons ys a)) (array)) xs)))
-
-        and_fold (foldl and true '(true true false true))
-        monad (array 'write  1 (str "Hello from compiled code! " and_fold "\n") (vau (written code) (array 'exit 0)))
- )
- monad
- )
-; end of all lets
-))))))
-; impl of let1
-; this would be the macro style version (((
-)) (vau de (s v b) (eval (array (array wrap (array vau (array s) b)) v) de)))
-;)) (vau de (s v b) (eval (array (array vau (array s) b) (eval v de)) de)))
-; impl of quote
-)) (vau (x5) x5))
diff --git a/fact.kp b/misc_tests/fact.kp
similarity index 100%
rename from fact.kp
rename to misc_tests/fact.kp
diff --git a/find.kp b/misc_tests/find.kp
similarity index 100%
rename from find.kp
rename to misc_tests/find.kp
diff --git a/int2hex.kp b/misc_tests/int2hex.kp
similarity index 100%
rename from int2hex.kp
rename to misc_tests/int2hex.kp
diff --git a/leftrotate32bit.kp b/misc_tests/leftrotate32bit.kp
similarity index 100%
rename from leftrotate32bit.kp
rename to misc_tests/leftrotate32bit.kp
diff --git a/misc_tests/t.kp b/misc_tests/t.kp
new file mode 100644
index 0000000..b23cf36
--- /dev/null
+++ b/misc_tests/t.kp
@@ -0,0 +1,15 @@
+((wrap (vau root_env (quote)
+((wrap (vau (let1)
+
+
+(array 'write  1 "enter form: " (vau (written code)
+      (array 'read 0 200 (vau (data code)
+            ((wrap (vau (asdf) (array 'exit (log (eval (log (read-string data))))))) code)
+            ;((wrap (vau (asdf) (array 'exit (eval (read-string data))))) code)
+            ;((wrap (vau (asdf) (array 'exit (cond (log "hi") written true code)))) code)
+      ))
+
+))
+
+)) (vau de (s v b) (eval (array (array wrap (array vau (array s) b)) v) de)))
+)) (vau (x5) x5))
diff --git a/to_compile.kp b/misc_tests/to_compile.kp
similarity index 99%
rename from to_compile.kp
rename to misc_tests/to_compile.kp
index f4101ee..73bd209 100644
--- a/to_compile.kp
+++ b/misc_tests/to_compile.kp
@@ -100,7 +100,6 @@
             destructure_helper (rec-lambda recurse (vs i r)
                 (cond (= (len vs) i)      r
                       (array? (idx vs i)) (let (bad_sym (str-to-symbol (str (idx vs i)))
-                                                ;new_vs (flat_map_i (lambda (i x) (array x (array idx bad_sym i))) (slice (idx vs i) 1 -1))
                                                 new_vs (flat_map_i (lambda (i x) (array x (array idx bad_sym i))) (idx vs i))
                                                 )
                                                 (recurse (concat new_vs (slice vs (+ i 2) -1)) 0 (concat r (array bad_sym (idx vs (+ i 1))))))
diff --git a/partial_eval.scm b/partial_eval.scm
index a9a959a..982e5b1 100644
--- a/partial_eval.scm
+++ b/partial_eval.scm
@@ -7,7 +7,7 @@
 
 ; Chez
 (define print pretty-print) (define arithmetic-shift bitwise-arithmetic-shift) (define foldl fold-left) (define foldr fold-right) (define write_file (lambda (file bytes) (let* ( (port (open-file-output-port file)) (_ (foldl (lambda (_ o) (put-u8 port o)) (void) bytes)) (_ (close-port port))) '()))) (define args (cdr (command-line)))
-(compile-profile 'source)
+;(compile-profile 'source)
 
 ; Gambit - Gambit also has a problem with the dlet definition (somehow recursing and making (cdr nil) for (cdr ls)?), even if using the unstable one that didn't break syntax-rules
 ;(define print pretty-print)
@@ -5879,7 +5879,7 @@
                    (true             (run-compiler (and (>= (len args) 2) (= "no_compile" (idx args 1))) com))))
 
        ;(true_print "GLOBAL_MAX was " GLOBAL_MAX)
-       (profile-dump-html)
+       ;(profile-dump-html)
    )
 )
 
diff --git a/matching.kp b/rb_tree_test/matching.kp
similarity index 100%
rename from matching.kp
rename to rb_tree_test/matching.kp
diff --git a/demo.sh b/small_demo/demo.sh
similarity index 65%
rename from demo.sh
rename to small_demo/demo.sh
index b2a8727..b863e77 100755
--- a/demo.sh
+++ b/small_demo/demo.sh
@@ -5,7 +5,7 @@ echo "Partially Evaluating & compiling " $@
 echo "Source is"
 cat $@
 echo
-touch csc_out.wasm && rm csc_out.wasm && time scheme --script ./partial_eval.scm $@
+touch csc_out.wasm && rm csc_out.wasm && time scheme --script ../partial_eval.scm $@
 echo
 echo "Running"
 echo
diff --git a/small_demo.kp b/small_demo/small_demo.kp
similarity index 100%
rename from small_demo.kp
rename to small_demo/small_demo.kp
diff --git a/small_lambda_demo.kp b/small_demo/small_lambda_demo.kp
similarity index 100%
rename from small_lambda_demo.kp
rename to small_demo/small_lambda_demo.kp
diff --git a/small_macro_demo.kp b/small_demo/small_macro_demo.kp
similarity index 100%
rename from small_macro_demo.kp
rename to small_demo/small_macro_demo.kp
diff --git a/small_demo/small_test.kp b/small_demo/small_test.kp
new file mode 100644
index 0000000..0fd8c88
--- /dev/null
+++ b/small_demo/small_test.kp
@@ -0,0 +1,154 @@
+((wrap (vau root_env (quote)
+((wrap (vau (let1)
+(let1 lambda (vau se (p b1) (wrap (eval (array vau p b1) se)))
+(let1 current-env (vau de () de)
+(let1 cons (lambda (h t) (concat (array h) t))
+(let1 Y (lambda (f3)
+    ((lambda (x1) (x1 x1))
+     (lambda (x2) (f3 (lambda (& y) (lapply (x2 x2) y))))))
+(let1 vY (lambda (f)
+    ((lambda (x3) (x3 x3))
+     (lambda (x4) (f (vau de1 (& y) (vapply (x4 x4) y de1))))))
+(let1 let (vY (lambda (recurse) (vau de2 (vs b) (cond (= (len vs) 0) (eval b de2)
+                                                     true           (vapply let1 (array (idx vs 0) (idx vs 1) (array recurse (slice vs 2 -1) b)) de2)))))
+ (let (
+         lcompose (lambda (g f) (lambda (& args) (lapply g (array (lapply f args)))))
+         rec-lambda (vau se (n p b) (eval (array Y (array lambda (array n) (array lambda p b))) se))
+         if (vau de (con than & else) (cond (eval con de) (eval than de)
+                                            (> (len else) 0) (eval (idx else 0) de)
+                                            true false))
+
+         map (lambda (f5 l5)
+             ; now maybe errors on can't find helper?
+             (let (helper (rec-lambda recurse (f4 l4 n4 i4)
+                                             (cond (= i4 (len l4))         n4
+                                                   (<= i4 (- (len l4) 4))  (recurse f4 l4 (concat n4 (array
+                                                                                                 (f4 (idx l4 (+ i4 0)))
+                                                                                                 (f4 (idx l4 (+ i4 1)))
+                                                                                                 (f4 (idx l4 (+ i4 2)))
+                                                                                                 (f4 (idx l4 (+ i4 3)))
+                                                                                                 )) (+ i4 4))
+                                                   true                  (recurse f4 l4 (concat n4 (array (f4 (idx l4 i4)))) (+ i4 1)))))
+                  (helper f5 l5 (array) 0)))
+
+
+        map_i (lambda (f l)
+            (let (helper (rec-lambda recurse (f l n i)
+                                            (cond (= i (len l))         n
+                                                  (<= i (- (len l) 4))  (recurse f l (concat n (array
+                                                                                                (f (+ i 0) (idx l (+ i 0)))
+                                                                                                (f (+ i 1) (idx l (+ i 1)))
+                                                                                                (f (+ i 2) (idx l (+ i 2)))
+                                                                                                (f (+ i 3) (idx l (+ i 3)))
+                                                                                                )) (+ i 4))
+                                                  true                  (recurse f l (concat n (array (f i (idx l i)))) (+ i 1)))))
+                 (helper f l (array) 0)))
+
+        filter_i (lambda (f l)
+               (let (helper (rec-lambda recurse (f l n i)
+                                            (if (= i (len l))
+                                                n
+                                                (if (f i (idx l i)) (recurse f l (concat n (array (idx l i))) (+ i 1))
+                                                                    (recurse f l n (+ i 1))))))
+                    (helper f l (array) 0)))
+        filter (lambda (f l) (filter_i (lambda (i x) (f x)) l))
+
+        not (lambda (x) (if x false true))
+
+        ; Huge thanks to Oleg Kiselyov for his fantastic website
+        ; http://okmij.org/ftp/Computation/fixed-point-combinators.html
+        Y* (lambda (& l)
+            ((lambda (u) (u u))
+             (lambda (p)
+                (map (lambda (li) (lambda (& x) (lapply (lapply li (p p)) x))) l))))
+        vY* (lambda (& l)
+            ((lambda (u) (u u))
+             (lambda (p)
+                (map (lambda (li) (vau ide (& x) (vapply (lapply li (p p)) x ide))) l))))
+
+        let-rec (vau de (name_func body)
+                    (let (names (filter_i (lambda (i x) (= 0 (% i 2))) name_func)
+                          funcs (filter_i (lambda (i x) (= 1 (% i 2))) name_func)
+                          overwrite_name (idx name_func (- (len name_func) 2)))
+                          (eval (array let (concat (array overwrite_name (concat (array Y*) (map (lambda (f) (array lambda names f)) funcs)))
+                                                                                (lapply concat (map_i (lambda (i n) (array n (array idx overwrite_name i))) names)))
+                                       body) de)))
+        let-vrec (vau de (name_func body)
+                    (let (names (filter_i (lambda (i x) (= 0 (% i 2))) name_func)
+                          funcs (filter_i (lambda (i x) (= 1 (% i 2))) name_func)
+                          overwrite_name (idx name_func (- (len name_func) 2)))
+                          (eval (array let (concat (array overwrite_name (concat (array vY*) (map (lambda (f) (array lambda names f)) funcs)))
+                                                                                (lapply concat (map_i (lambda (i n) (array n (array idx overwrite_name i))) names)))
+                                       body) de)))
+
+        flat_map (lambda (f l)
+            (let (helper (rec-lambda recurse (f l n i)
+                                            (if (= i (len l))
+                                                n
+                                                (recurse f l (concat n (f (idx l i))) (+ i 1)))))
+                 (helper f l (array) 0)))
+        flat_map_i (lambda (f l)
+            (let (helper (rec-lambda recurse (f l n i)
+                                            (if (= i (len l))
+                                                n
+                                                (recurse f l (concat n (f i (idx l i))) (+ i 1)))))
+                 (helper f l (array) 0)))
+
+        ; with all this, we make a destrucutring-capable let
+        let (let (
+            destructure_helper (rec-lambda recurse (vs i r)
+                (cond (= (len vs) i)      r
+                      (array? (idx vs i)) (let (bad_sym (str-to-symbol (str (idx vs i)))
+                                                ;new_vs (flat_map_i (lambda (i x) (array x (array idx bad_sym i))) (slice (idx vs i) 1 -1))
+                                                new_vs (flat_map_i (lambda (i x) (array x (array idx bad_sym i))) (idx vs i))
+                                                )
+                                                (recurse (concat new_vs (slice vs (+ i 2) -1)) 0 (concat r (array bad_sym (idx vs (+ i 1))))))
+                      true                (recurse vs (+ i 2) (concat r (slice vs i (+ i 2))))
+            ))) (vau de (vs b) (vapply let (array (destructure_helper vs 0 (array)) b) de)))
+
+        ; and a destructuring-capable lambda!
+        only_symbols (rec-lambda recurse (a i) (cond (= i (len a))       true
+                                                     (symbol? (idx a i)) (recurse a (+ i 1))
+                                                     true                false))
+
+        ; Note that if macro_helper is inlined, the mapping lambdas will close over
+        ; se, and then not be able to be taken in as values to the maps, and the vau
+        ; will fail to partially evaluate away.
+        lambda (let (macro_helper (lambda (p b) (let (
+                        sym_params (map (lambda (param) (if (symbol? param) param
+                                                                            (str-to-symbol (str param)))) p)
+                        body (array let (flat_map_i (lambda (i x) (array (idx p i) x)) sym_params) b)
+                      ) (array vau sym_params body))))
+                    (vau se (p b) (if (only_symbols p 0) (vapply lambda (array p b) se)
+                                                         (wrap (eval (macro_helper p b) se)))))
+
+        ; and rec-lambda - yes it's the same definition again
+        rec-lambda (vau se (n p b) (eval (array Y (array lambda (array n) (array lambda p b))) se))
+
+        nil (array)
+        or  (let (macro_helper (rec-lambda recurse (bs i) (cond (= i       (len bs)) false
+                                                                (= (+ 1 i) (len bs)) (idx bs i)
+                                                                true       (array let (array 'tmp (idx bs i)) (array if 'tmp 'tmp (recurse bs (+ i 1)))))))
+                 (vau se (& bs) (eval (macro_helper bs 0) se)))
+        and (let (macro_helper (rec-lambda recurse (bs i) (cond (= i       (len bs)) true
+                                                                (= (+ 1 i) (len bs)) (idx bs i)
+                                                                true       (array let (array 'tmp (idx bs i)) (array if 'tmp (recurse bs (+ i 1)) 'tmp)))))
+                 (vau se (& bs) (eval (macro_helper bs 0) se)))
+
+
+         test17 (or false 1 "a" true)
+         test18 (and 1 "a" nil true)
+         monad (array 'write  1 "test_self_out2" (vau (written code) (array (or written code) test17 (or false nil 0) (and written code) test18 (and nil 0 false))))
+
+ )
+  monad
+ )
+ ;(array 'write  1 "test_self_out2" (vau (written code) 7))
+; end of all lets
+))))))
+; impl of let1
+; this would be the macro style version (((
+)) (vau de (s v b) (eval (array (array wrap (array vau (array s) b)) v) de)))
+;)) (vau de (s v b) (eval (array (array vau (array s) b) (eval v de)) de)))
+; impl of quote
+)) (vau (x5) x5))
diff --git a/small_vau_demo.kp b/small_demo/small_vau_demo.kp
similarity index 100%
rename from small_vau_demo.kp
rename to small_demo/small_vau_demo.kp
diff --git a/table.md b/table.md
deleted file mode 100644
index 2895152..0000000
--- a/table.md
+++ /dev/null
@@ -1,12 +0,0 @@
-| Command | Mean [ms] | Min [ms] | Max [ms] | Relative |
-|:---|---:|---:|---:|---:|
-| `echo 30 \| wasmtime ./fib_compiled.wasm` | 106.3 ± 1.7 | 103.8 | 111.8 | 8.18 ± 0.35 |
-| `echo 30 \| wasmtime ./fib_compiled_let.wasm` | 142.1 ± 1.5 | 140.0 | 144.9 | 10.93 ± 0.45 |
-| `echo 30 \| wasmtime ./builtin_fib.wasm` | 13.0 ± 0.5 | 11.7 | 14.7 | 1.00 |
-| `echo 30 \| wasmtime ./fib_compiled_manual.wasm` | 305.9 ± 3.2 | 301.8 | 311.7 | 23.53 ± 0.98 |
-| `scheme --script ./fib.scm 30` | 53.9 ± 0.6 | 53.0 | 56.0 | 4.15 ± 0.17 |
-| `scheme --script ./fib_let.scm 30` | 54.0 ± 0.6 | 53.1 | 55.6 | 4.15 ± 0.17 |
-| `python3 ./fib.py 30` | 287.6 ± 2.7 | 283.8 | 293.1 | 22.12 ± 0.91 |
-| `python3 ./fib_let.py 30` | 303.8 ± 2.9 | 300.5 | 308.0 | 23.37 ± 0.97 |
-| `echo 30 \| wasmtime ./rust_fib/target/wasm32-wasi/debug/rust_let.wasm` | 29.7 ± 0.6 | 28.5 | 32.3 | 2.29 ± 0.10 |
-| `echo 30 \| wasmtime ./rust_fib/target/wasm32-wasi/release/rust_let.wasm` | 18.6 ± 0.4 | 17.8 | 19.8 | 1.43 ± 0.06 |