diff --git a/dsl/src/dsl_provide.rs b/dsl/src/dsl_provide.rs
index cbd99ff..d9896de 100644
--- a/dsl/src/dsl_provide.rs
+++ b/dsl/src/dsl_provide.rs
@@ -1,39 +1,39 @@
 use crate::*;
 
-pub trait Dsl<Type> {
-    fn take <'source> (&self, token: &mut TokenIter<'source>) -> Perhaps<Type>;
-    fn take_or_fail <'source> (
-        &self, token: &mut TokenIter<'source>, error: impl Into<Box<dyn std::error::Error>>
-    ) -> Usually<Type> {
-        if let Some(value) = Dsl::<Type>::take(self, token)? {
+pub trait Dsl<Other>: Sized {
+    fn take <'state, 'source: 'state> (
+        &'state self,
+        token: &mut TokenIter<'source>
+    )
+        -> Perhaps<Other>;
+    fn take_or_fail <'state, 'source: 'state> (
+        &'state self,
+        token: &mut TokenIter<'source>,
+        error: impl Into<Box<dyn std::error::Error>>
+    ) -> Usually<Other> {
+        if let Some(value) = Dsl::<Other>::take(self, token)? {
             Ok(value)
         } else {
             Result::Err(error.into())
         }
     }
 }
-
-impl<Type: Namespace<State>, State> Dsl<Type> for State {
-    fn take <'source> (&self, token: &mut TokenIter<'source>) -> Perhaps<Type> {
-        Namespace::take_from(self, token)
-    }
-}
-
-pub trait Namespace<State>: Sized {
-    fn take_from <'source> (state: &State, token: &mut TokenIter<'source>)
+pub trait FromDsl<'source, State>: Sized {
+    fn take_from <'state> (state: &'state State, token: &mut TokenIter<'source>)
         -> Perhaps<Self>;
-    fn take_from_or_fail <'source> (
-        state: &State, token: &mut TokenIter<'source>, error: impl Into<Box<dyn std::error::Error>>
+    fn take_from_or_fail <'state> (
+        state: &'state State,
+        token: &mut TokenIter<'source>,
+        error: impl Into<Box<dyn std::error::Error>>
     ) -> Usually<Self> {
-        if let Some(value) = Namespace::<State>::take_from(state, token)? {
+        if let Some(value) = FromDsl::<State>::take_from(state, token)? {
             Ok(value)
         } else {
             Result::Err(error.into())
         }
     }
 }
-
-//impl<State: Dsl<T>, T> Namespace<State> for T {
+//impl<State: Dsl<T>, T> FromDsl<State> for T {
     //fn take_from <'state, 'source: 'state> (state: &'state State, token: &mut TokenIter<'source>)
         //-> Perhaps<Self>
     //{
@@ -45,9 +45,9 @@ pub trait Namespace<State>: Sized {
 /// specifying two types and providing an expression.
 #[macro_export] macro_rules! from_dsl {
     (@a: $T:ty: |$state:ident, $words:ident|$expr:expr) => {
-        impl<State: Dsl<A>, A> Namespace<State> for $T {
-            fn take_from <'source> (
-                $state: &State,
+        impl<'source, State: Dsl<A>, A> FromDsl<'source, State> for $T {
+            fn take_from <'state> (
+                $state: &'state State,
                 $words: &mut TokenIter<'source>,
             ) -> Perhaps<$T> {
                 $expr
@@ -55,9 +55,9 @@ pub trait Namespace<State>: Sized {
         }
     };
     (@ab: $T:ty: |$state:ident, $words:ident|$expr:expr) => {
-        impl<State: Dsl<A> + Dsl<B>, A, B> Namespace<State> for $T {
-            fn take_from <'source> (
-                $state: &State,
+        impl<'source, State: Dsl<A> + Dsl<B>, A, B> FromDsl<'source, State> for $T {
+            fn take_from <'state> (
+                $state: &'state State,
                 $words: &mut TokenIter<'source>,
             ) -> Perhaps<$T> {
                 $expr
@@ -65,9 +65,9 @@ pub trait Namespace<State>: Sized {
         }
     };
     ($T:ty: |$state:ident:$S:ty, $words:ident|$expr:expr) => {
-        impl Namespace<$S> for $T {
-            fn take_from <'source> (
-                $state: &$S,
+        impl<'source> FromDsl<'source, $S> for $T {
+            fn take_from <'state> (
+                $state: &'state $S,
                 $words: &mut TokenIter<'source>,
             ) -> Perhaps<$T> {
                 $expr
diff --git a/input/src/input_dsl.rs b/input/src/input_dsl.rs
index 046417a..2856c89 100644
--- a/input/src/input_dsl.rs
+++ b/input/src/input_dsl.rs
@@ -5,13 +5,13 @@ use std::marker::PhantomData;
 pub trait DslInput: Input { fn matches_dsl (&self, token: &str) -> bool; }
 
 /// A pre-configured mapping of input events to commands.
-pub trait KeyMap<'source, S, C: Namespace<S> + Command<S>, I: DslInput> {
+pub trait KeyMap<'source, S, C: FromDsl<'source, S> + Command<S>, I: DslInput> {
     /// Try to find a command that matches the current input event.
     fn keybind_resolve (&self, state: &S, input: &I) -> Perhaps<C>;
 }
 
 /// A [SourceIter] can be a [KeyMap].
-impl<'source, S, C: Namespace<S> + Command<S>, I: DslInput>
+impl<'source, S, C: FromDsl<'source, S> + Command<S>, I: DslInput>
 KeyMap<'source, S, C, I>
 for SourceIter<'source> {
     fn keybind_resolve (&self, state: &S, input: &I) -> Perhaps<C> {
@@ -24,7 +24,7 @@ for SourceIter<'source> {
                     match exp_iter.next() {
                         Some(Token { value: Value::Sym(binding), .. }) => {
                             if input.matches_dsl(binding) {
-                                if let Some(command) = Namespace::take_from(state, &mut exp_iter)? {
+                                if let Some(command) = FromDsl::take_from(state, &mut exp_iter)? {
                                     return Ok(Some(command))
                                 }
                             }
@@ -40,7 +40,7 @@ for SourceIter<'source> {
 }
 
 /// A [TokenIter] can be a [KeyMap].
-impl<'source, S, C: Namespace<S> + Command<S>, I: DslInput>
+impl<'source, S, C: FromDsl<'source, S> + Command<S>, I: DslInput>
 KeyMap<'source, S, C, I>
 for TokenIter<'source> {
     fn keybind_resolve (&self, state: &S, input: &I) -> Perhaps<C> {
@@ -52,7 +52,7 @@ for TokenIter<'source> {
                     match e.next() {
                         Some(Token { value: Value::Sym(binding), .. }) => {
                             if input.matches_dsl(binding) {
-                                if let Some(command) = Namespace::take_from(state, &mut e)? {
+                                if let Some(command) = FromDsl::take_from(state, &mut e)? {
                                     return Ok(Some(command))
                                 }
                             }
@@ -67,24 +67,23 @@ for TokenIter<'source> {
     }
 }
 
-pub type InputCondition<'source, S> =
-    Box<dyn Fn(&S)->Usually<bool> + Send + Sync + 'source>;
+pub type InputLayerCond<'source, S> = Box<dyn Fn(&S)->Usually<bool> + 'source>;
 
 /// A collection of pre-configured mappings of input events to commands,
 /// which may be made available subject to given conditions.
 pub struct InputMap<'source,
     S,
-    C: Command<S> + Namespace<S>,
+    C: Command<S> + FromDsl<'source, S>,
     I: DslInput,
     M: KeyMap<'source, S, C, I>
 > {
     __: PhantomData<&'source (S, C, I)>,
-    pub layers: Vec<(InputCondition<'source, S>, M)>,
+    pub layers: Vec<(InputLayerCond<'source, S>, M)>,
 }
 
 impl<'source,
     S,
-    C: Command<S> + Namespace<S>,
+    C: Command<S> + FromDsl<'source, S>,
     I: DslInput,
     M: KeyMap<'source, S, C, I>
 > Default for InputMap<'source, S, C, I, M>{
@@ -95,7 +94,7 @@ impl<'source,
 
 impl<'source,
     S,
-    C: Command<S> + Namespace<S>,
+    C: Command<S> + FromDsl<'source, S>,
     I: DslInput,
     M: KeyMap<'source, S, C, I>
 > InputMap<'source, S, C, I, M> {
@@ -110,11 +109,11 @@ impl<'source,
         self.add_layer_if(Box::new(|_|Ok(true)), keymap);
         self
     }
-    pub fn layer_if (mut self, condition: InputCondition<'source, S>, keymap: M) -> Self {
+    pub fn layer_if (mut self, condition: InputLayerCond<'source, S>, keymap: M) -> Self {
         self.add_layer_if(condition, keymap);
         self
     }
-    pub fn add_layer_if (&mut self, condition: InputCondition<'source, S>, keymap: M) -> &mut Self {
+    pub fn add_layer_if (&mut self, condition: InputLayerCond<'source, S>, keymap: M) -> &mut Self {
         self.layers.push((Box::new(condition), keymap));
         self
     }
@@ -122,7 +121,7 @@ impl<'source,
 
 impl<'source,
     S,
-    C: Command<S> + Namespace<S>,
+    C: Command<S> + FromDsl<'source, S>,
     I: DslInput,
     M: KeyMap<'source, S, C, I>
 > std::fmt::Debug for InputMap<'source, S, C, I, M> {
@@ -134,7 +133,7 @@ impl<'source,
 /// An [InputMap] can be a [KeyMap].
 impl<'source,
     S,
-    C: Command<S> + Namespace<S>,
+    C: Command<S> + FromDsl<'source, S>,
     I: DslInput,
     M: KeyMap<'source, S, C, I>
 > KeyMap<'source, S, C, I> for InputMap<'source, S, C, I, M> {
diff --git a/output/src/ops.rs b/output/src/ops.rs
index 7eba655..4c6ea2a 100644
--- a/output/src/ops.rs
+++ b/output/src/ops.rs
@@ -2,7 +2,6 @@ mod align;     pub use self::align::*;
 mod bsp;       pub use self::bsp::*;
 mod cond;      pub use self::cond::*;
 mod map;       pub use self::map::*;
-mod memo;      pub use self::memo::*;
 mod stack;     pub use self::stack::*;
 //mod reduce;    pub use self::reduce::*;
 mod thunk;     pub use self::thunk::*;
diff --git a/output/src/ops/cond.rs b/output/src/ops/cond.rs
index be950fe..e0dde77 100644
--- a/output/src/ops/cond.rs
+++ b/output/src/ops/cond.rs
@@ -14,13 +14,13 @@ pub struct Either<A, B>(pub bool, pub A, pub B);
 impl<A, B> Either<A, B> {
     /// Create a ternary condition.
     pub const fn new (c: bool, a: A, b: B) -> Self {
-        Self(c, a, b)
+        Self(c, a, b) 
     }
 }
 #[cfg(feature = "dsl")]
-impl<A, T: Dsl<bool> + Dsl<A>> Namespace<T> for When<A> {
-    fn take_from <'source> (
-        state: &T,
+impl<'source, A, T: Dsl<bool> + Dsl<A>> FromDsl<'source, T> for When<A> {
+    fn take_from <'state> (
+        state: &'state T,
         token: &mut TokenIter<'source>
     ) -> Perhaps<Self> {
         Ok(if let Some(Token {
@@ -56,9 +56,9 @@ impl<E: Output, A: Render<E>> Content<E> for When<A> {
     }
 }
 #[cfg(feature = "dsl")]
-impl<A, B, T: Dsl<bool> + Dsl<A> + Dsl<B>> Namespace<T> for Either<A, B> {
-    fn take_from <'source> (
-        state: &T,
+impl<'source, A, B, T: Dsl<bool> + Dsl<A> + Dsl<B>> FromDsl<'source, T> for Either<A, B> {
+    fn take_from <'state> (
+        state: &'state T,
         token: &mut TokenIter<'source>
     ) -> Perhaps<Self> {
         if let Some(Token { value: Value::Key("either"), .. }) = token.peek() {
diff --git a/output/src/ops/memo.rs b/output/src/ops/memo.rs
deleted file mode 100644
index 07e2d93..0000000
--- a/output/src/ops/memo.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-use crate::*;
-use std::sync::{Arc, RwLock};
-
-#[derive(Debug, Default)] pub struct Memo<T, U> {
-    pub value: T,
-    pub view: Arc<RwLock<U>>
-}
-
-impl<T: PartialEq, U> Memo<T, U> {
-    pub fn new (value: T, view: U) -> Self {
-        Self { value, view: Arc::new(view.into()) }
-    }
-    pub fn update <R> (
-        &mut self,
-        newval: T,
-        render: impl Fn(&mut U, &T, &T)->R
-    ) -> Option<R> {
-        if newval != self.value {
-            let result = render(&mut*self.view.write().unwrap(), &newval, &self.value);
-            self.value = newval;
-            return Some(result);
-        }
-        None
-    }
-}
-
-/// Clear a pre-allocated buffer, then write into it.
-#[macro_export] macro_rules! rewrite {
-    ($buf:ident, $($rest:tt)*) => { |$buf,_,_|{ $buf.clear(); write!($buf, $($rest)*) } }
-}
diff --git a/output/src/ops/transform.rs b/output/src/ops/transform.rs
index 776d95c..808f56b 100644
--- a/output/src/ops/transform.rs
+++ b/output/src/ops/transform.rs
@@ -33,19 +33,17 @@ macro_rules! transform_xy {
             #[inline] pub const fn xy (item: A) -> Self { Self::XY(item) }
         }
         #[cfg(feature = "dsl")]
-        impl<A, T: Dsl<A>> Namespace<T> for $Enum<A> {
-            fn take_from <'source> (
-                state: &T, token: &mut TokenIter<'source>
-            ) -> Perhaps<Self> {
-                if let Some(Token { value: Value::Key(k), .. }) = token.peek() {
-                    let mut base = token.clone();
-                    return Ok(Some(match token.next() {
+        impl<'source, A, T: Dsl<A>> FromDsl<'source, T> for $Enum<A> {
+            fn take_from <'state> (state: &'state T, iter: &mut TokenIter<'source>) -> Perhaps<Self> {
+                if let Some(Token { value: Value::Key(k), .. }) = iter.peek() {
+                    let mut base = iter.clone();
+                    return Ok(Some(match iter.next() {
                         Some(Token{value:Value::Key($x),..}) =>
-                            Self::x(state.take_or_fail(token, "x: no content")?),
+                            Self::x(state.take_or_fail(iter, "x: no content")?),
                         Some(Token{value:Value::Key($y),..}) =>
-                            Self::y(state.take_or_fail(token, "y: no content")?),
+                            Self::y(state.take_or_fail(iter, "y: no content")?),
                         Some(Token{value:Value::Key($xy),..}) =>
-                            Self::xy(state.take_or_fail(token, "xy: no content")?),
+                            Self::xy(state.take_or_fail(iter, "xy: no content")?),
                         _ => unreachable!()
                     }))
                 }
@@ -79,25 +77,23 @@ macro_rules! transform_xy_unit {
             #[inline] pub const fn xy (x: U, y: U, item: A) -> Self { Self::XY(x, y, item) }
         }
         #[cfg(feature = "dsl")]
-        impl<A, U: Coordinate, T: Dsl<A> + Dsl<U>> Namespace<T> for $Enum<U, A> {
-            fn take_from <'source> (
-                state: &T, token: &mut TokenIter<'source>
-            ) -> Perhaps<Self> {
-                Ok(if let Some(Token { value: Value::Key($x|$y|$xy), .. }) = token.peek() {
-                    let mut base = token.clone();
-                    Some(match token.next() {
+        impl<'source, A, U: Coordinate, T: Dsl<A> + Dsl<U>> FromDsl<'source, T> for $Enum<U, A> {
+            fn take_from <'state> (state: &'state T, iter: &mut TokenIter<'source>) -> Perhaps<Self> {
+                Ok(if let Some(Token { value: Value::Key($x|$y|$xy), .. }) = iter.peek() {
+                    let mut base = iter.clone();
+                    Some(match iter.next() {
                         Some(Token { value: Value::Key($x), .. }) => Self::x(
-                            state.take_or_fail(token, "x: no unit")?,
-                            state.take_or_fail(token, "x: no content")?,
+                            state.take_or_fail(iter, "x: no unit")?,
+                            state.take_or_fail(iter, "x: no content")?,
                         ),
                         Some(Token { value: Value::Key($y), .. }) => Self::y(
-                            state.take_or_fail(token, "y: no unit")?,
-                            state.take_or_fail(token, "y: no content")?,
+                            state.take_or_fail(iter, "y: no unit")?,
+                            state.take_or_fail(iter, "y: no content")?,
                         ),
                         Some(Token { value: Value::Key($x), .. }) => Self::xy(
-                            state.take_or_fail(token, "xy: no unit x")?,
-                            state.take_or_fail(token, "xy: no unit y")?,
-                            state.take_or_fail(token, "xy: no content")?
+                            state.take_or_fail(iter, "xy: no unit x")?,
+                            state.take_or_fail(iter, "xy: no unit y")?,
+                            state.take_or_fail(iter, "xy: no content")?
                         ),
                         _ => unreachable!(),
                     })
diff --git a/output/src/view.rs b/output/src/view.rs
index ae252d9..2ae266e 100644
--- a/output/src/view.rs
+++ b/output/src/view.rs
@@ -13,7 +13,7 @@ use crate::*;
 //// Provides components to the view.
 //#[cfg(feature = "dsl")]
 //pub trait ViewContext<'state, E: Output + 'state>:
-    //Namespace<bool> + Namespace<usize> + Namespace<E::Unit> + Send + Sync
+    //FromDsl<bool> + FromDsl<usize> + FromDsl<E::Unit> + Send + Sync
 //{
     //fn get_content_sym <'source: 'state> (&'state self, iter: &mut TokenIter<'source>)
         //-> Perhaps<RenderBox<'state, E>>;
@@ -39,7 +39,7 @@ use crate::*;
 //}
 
 //#[cfg(feature = "dsl")]
-//impl<'context, O: Output + 'context, T: ViewContext<'context, O>> Namespace<T> for RenderBox<'context, O> {
+//impl<'context, O: Output + 'context, T: ViewContext<'context, O>> FromDsl<T> for RenderBox<'context, O> {
     //fn take_from <'state, 'source: 'state> (state: &'state T, token: &mut TokenIter<'source>)
         //-> Perhaps<RenderBox<'context, O>>
     //{
diff --git a/proc/src/proc_command.rs b/proc/src/proc_command.rs
index 95f7a42..a8ca8c9 100644
--- a/proc/src/proc_command.rs
+++ b/proc/src/proc_command.rs
@@ -84,7 +84,7 @@ impl ToTokens for CommandDef {
                         let mut out = TokenStream2::new();
                         for (arg, ty) in arm.args() {
                             write_quote_to(&mut out, quote! {
-                                #arg: Namespace::take_from_or_fail(self, words)?,
+                                #arg: FromDsl::take_from_or_fail(self, words)?,
                             });
                         }
                         out
@@ -149,9 +149,9 @@ impl ToTokens for CommandDef {
                 }
             }
             /// Generated by [tengri_proc::command].
-            impl ::tengri::dsl::Namespace<#state> for #command_enum {
-                fn take_from <'source> (
-                    state: &#state,
+            impl<'source> ::tengri::dsl::FromDsl<'source, #state> for #command_enum {
+                fn take_from <'state> (
+                    state: &'state #state,
                     words: &mut ::tengri::dsl::TokenIter<'source>
                 ) -> Perhaps<Self> {
                     let mut words = words.clone();
diff --git a/proc/src/proc_expose.rs b/proc/src/proc_expose.rs
index bf951b5..f7b934e 100644
--- a/proc/src/proc_expose.rs
+++ b/proc/src/proc_expose.rs
@@ -85,9 +85,9 @@ impl ToTokens for ExposeImpl {
             let values = variants.iter().map(ExposeArm::from);
             write_quote_to(out, quote! {
                 /// Generated by [tengri_proc::expose].
-                impl ::tengri::dsl::Namespace<#state> for #t {
-                    fn take_from <'source> (
-                        state: &#state,
+                impl<'source> ::tengri::dsl::FromDsl<'source, #state> for #t {
+                    fn take_from <'state> (
+                        state: &'state #state,
                         words: &mut ::tengri::dsl::TokenIter<'source>
                     ) -> Perhaps<Self> {
                         Ok(Some(match words.next().map(|x|x.value) {
diff --git a/proc/src/proc_view.rs b/proc/src/proc_view.rs
index 7223dc0..70511eb 100644
--- a/proc/src/proc_view.rs
+++ b/proc/src/proc_view.rs
@@ -43,15 +43,10 @@ impl ToTokens for ViewDef {
     fn to_tokens (&self, out: &mut TokenStream2) {
         let Self(ViewMeta { output }, ViewImpl { block, exposed }) = self;
         let view = &block.self_ty;
-        let builtins = builtins().iter().map(|ty|write_quote(quote! {
-            if let Some(value) = Namespace::<#ty>::take_from(state, &mut exp.clone())? {
-                return Ok(Some(value.boxed()))
-            }
-        })).collect::<Vec<_>>();
         let mut available = vec![];
         let exposed: Vec<_> = exposed.iter().map(|(key, value)|{
             available.push(key.clone());
-            write_quote(quote! { #key => Some(#view::#value(state).boxed()), })
+            write_quote(quote! { #key => Some(state.#value().boxed()), })
         }).collect();
         let available: String = available.join(", ");
         let error_msg = LitStr::new(
@@ -75,26 +70,23 @@ impl ToTokens for ViewDef {
             /// Gives [#view] the ability to construct the [Render]able
             /// which might corresponds to a given [TokenStream],
             /// while taking [#view]'s state into consideration.
-            impl ::tengri::dsl::Namespace<#view> for Box<dyn Render<#output>> {
-                fn take_from <'source> (
-                    state: &#view,
-                    words: &mut ::tengri::dsl::TokenIter<'source>
+            impl<'source> ::tengri::dsl::FromDsl<'source, #view> for Box<dyn Render<#output> + 'source> {
+                fn take_from <'state> (
+                    state: &'state #view,
+                    words: &mut ::tengri::dsl::TokenIter<'source>,
                 ) -> Perhaps<Self> {
-                    Ok(if let Some(::tengri::dsl::Token { value, .. }) = words.peek() {
-                        match value {
-                            ::tengri::dsl::Value::Exp(_, exp) => {
-                                //#(#builtins)*
-                                None
-                            },
-                            ::tengri::dsl::Value::Sym(sym) => match sym {
-                                #(#exposed)*
-                                _ => None
-                            },
+                    Ok(words.peek().and_then(|::tengri::dsl::Token{ value, .. }|match value {
+                        ::tengri::dsl::Value::Exp(_, exp) => {
+                            todo!("builtin layout ops");
+                            //#builtins
+                            None
+                        },
+                        ::tengri::dsl::Value::Sym(sym) => match sym {
+                            #(#exposed)*
                             _ => None
-                        }
-                    } else {
-                        None
-                    })
+                        },
+                        _ => None
+                    }))
                 }
             }
         })
@@ -103,19 +95,19 @@ impl ToTokens for ViewDef {
 
 fn builtins () -> [TokenStream2;14] {
     [
-        quote! { When::<_>       },
-        quote! { Either::<_, _>  },
-        quote! { Align::<_>      },
-        quote! { Bsp::<_, _>     },
-        quote! { Fill::<_>       },
-        quote! { Fixed::<_, _>   },
-        quote! { Min::<_, _>     },
-        quote! { Max::<_, _>     },
-        quote! { Shrink::<_, _>  },
-        quote! { Expand::<_, _>  },
-        quote! { Push::<_, _>    },
-        quote! { Pull::<_, _>    },
-        quote! { Margin::<_, _>  },
-        quote! { Padding::<_, _> },
+        quote! { When::<A>       },
+        quote! { Either::<A, B>  },
+        quote! { Align::<A>      },
+        quote! { Bsp::<A, B>     },
+        quote! { Fill::<A>       },
+        quote! { Fixed::<_, A>   },
+        quote! { Min::<_, A>     },
+        quote! { Max::<_, A>     },
+        quote! { Shrink::<_, A>  },
+        quote! { Expand::<_, A>  },
+        quote! { Push::<_, A>    },
+        quote! { Pull::<_, A>    },
+        quote! { Margin::<_, A>  },
+        quote! { Padding::<_, A> },
     ]
 }
diff --git a/tui/src/tui_content.rs b/tui/src/tui_content.rs
index 1b9cc1b..0d563fd 100644
--- a/tui/src/tui_content.rs
+++ b/tui/src/tui_content.rs
@@ -12,18 +12,6 @@ macro_rules! impl_content_layout_render {
     }
 }
 
-mod tui_border;   pub use self::tui_border::*;
-mod tui_button;   pub use self::tui_button::*;
-mod tui_color;    pub use self::tui_color::*;
-mod tui_field;    pub use self::tui_field::*;
-mod tui_phat;     pub use self::tui_phat::*;
-mod tui_repeat;   pub use self::tui_repeat::*;
-mod tui_number;   pub use self::tui_number::*;
-mod tui_scroll;   pub use self::tui_scroll::*;
-mod tui_string;   pub use self::tui_string::*;
-mod tui_style;    pub use self::tui_style::*;
-mod tui_tryptich; pub use self::tui_tryptich::*;
-
 impl<T: Content<TuiOut>> Content<TuiOut> for std::sync::Arc<T> {
     fn layout (&self, to: [u16;4]) -> [u16;4] {
         Content::<TuiOut>::layout(&**self, to)
@@ -56,3 +44,14 @@ impl<T: Content<TuiOut>> Content<TuiOut> for Result<T, Box<dyn std::error::Error
         //}
     //}
 //}
+
+mod tui_border;   pub use self::tui_border::*;
+mod tui_button;   pub use self::tui_button::*;
+mod tui_color;    pub use self::tui_color::*;
+mod tui_field;    pub use self::tui_field::*;
+mod tui_phat;     pub use self::tui_phat::*;
+mod tui_repeat;   pub use self::tui_repeat::*;
+mod tui_scroll;   pub use self::tui_scroll::*;
+mod tui_string;   pub use self::tui_string::*;
+mod tui_style;    pub use self::tui_style::*;
+mod tui_tryptich; pub use self::tui_tryptich::*;
diff --git a/tui/src/tui_content/tui_number.rs b/tui/src/tui_content/tui_number.rs
deleted file mode 100644
index 8e283ce..0000000
--- a/tui/src/tui_content/tui_number.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-use crate::*;
-
-render!(TuiOut: |self: u64, to|todo!());
-
-render!(TuiOut: |self: f64, to|todo!());