T.js - A tiny templating framework in ~400 bytes

    function template(str,data){
        for(var i in data){
            str=str.replace(new RegExp("{("+i+")}","g"),data[i])
        }
        return str
    }

    txt = template('hello {name}!',{name:'Jen'})

    txt = template('days: {0}, {1} and {2}',['mon','tue','wed'])

* Looks coincidentally similar to Fuchs'

Notably, the examples found at https://gist.github.com/964762#file_test.js has the closest parity.

Edit: On second thought, I think the previous gist can reach parity with just a helper function for iterating and escaping:

  function engine(a,b){return function(c,d){return a.replace(/#{([^}]*)}/g,function(a,e){return Function("x","with(x)return "+e).call(c,d||b||{})})}}

  function iterator(o, k, f){
    var i, v = [];
    for(i in o[k]){
      v = v.concat(f(o, k, i));
    }
    return v.join('');
  }

  function print_kv(o, k, i){
    return [" ", i, ":", o[k][i]];
  }

  hello = engine("Hello,#{iterator(this, 'users', print_user)}!")
  // We don't have to pass iterator, on the next line, but it should demonstrate
  // how we context can be overwritten
  hello({users: {a: 1, b: 2, c:3}}, {iterator: iterator, print_user: print_kv})

  // Or don't pass print_user
  print_user = print_kv
  hello({users: {a: 1, b: 2, c:3}})
  // "Hello, a:1 b:2 c:3!"

  // Overload it!
  hello({users: {a: 1, b: 2, c:3}}, {print_user: function(o, k, i){return " "+i}})
  // "Hello, a b c!"

    var render = function(src, data) {
        return src.replace(/{{(.*?)}}/g, function(w, p) {
            return data[p];
        });
    };

EDIT Xeon 3050 has 2MB of L2 cache, so the answer is probably yes!

I haven't properly updated the gist fork yet, but as follows are the semi-minified additions [of `safe` and `map` (iter)] and parity tests.

  function t(a,b){
    return function(c,d){
      return a.replace(/#{([^}]*)}/g, function(a,e){
          function safe(v){return new Option(v).innerHTML;}
          function map(o, f){
            var k, v = [];
            for(k in o) v.push(f(k, o[k]));
            return v;
          }
          return Function("x",safe+map+"with(x)return "+e).call(c,d||b||{})
      })
    }
  }
  function l(v){
    console.log(v);
  }

  // Simple interpolation: {{=value}}
  l(t("Hello, #{this.name}!")({name: "Mike"}));

  // Scrubbed interpolation: {{%unsafe_value}}
  l(t("Saved from #{safe(this.xss)}!")({xss: "<script>alert('xss')<\/script>"}));

  // Name-spaced variables: {{=User.address.city}}
  l(t("Hello1, #{this.user.name}!")({user: {name: "Mike"}}));

  // If/else blocks: {{value}} <<markup>> {{:value}} <<alternate markup>> {{/value}}
  l(t("Hello2, #{this.name || 'World'}!")({name: "Mike"}));
  l(t("Hello2, #{this.name || 'World'}!")());
  l(t("Hello2, #{this.u ? this.u.name : 'World'}!")({u: {name: "Mike"}}));

  // If not blocks: {{!value}} <<markup>> {{/value}}
  l(t("Hello3, #{!this.u ? 'World' : ''}!")({user: {name: "Mike"}}));

  // Object/Array iteration: {{@object_value}} {{=_key}}:{{=_val}} {{/@object_value}}
  l(t("Hello4, #{map(this.users, print_user).join(', ')}!", {
        print_user: function(k, user){return user;}
  })({users: ["Mike", "John", "Bill"]}));

  // Maybe you have one of those new-fangled browsers w/ builtin map
  l(t("Hello4, #{this.users.map(print_user).join(', ')}!", {
        print_user: function(user){return user;}
  })({users: ["Mike", "John", "Bill"]}));

  // Let's go deeper...
  l(t("Hello4, #{map(this.users, user).join(', ')}!", {
        user: function(_, user){
          return t("#{safe(this.name)}")(user);
        }
  })({users:[{name: "Mike"}, {name: "John<3"}, {name: "Bill"}]}));

  // Render the same template multiple times with different data
  hello = t("Hello5, and #{this.goodbye}!");
  l(hello({goodbye: "goodbye"}));
  l(hello({goodbye: "good night"}));

  function render(tpl,data){
  	var matches = tpl.match(/{[^\}]+}/g);
  	for(var i in matches){
  		var rep =   eval("data."+matches[i].replace('{','').replace('}',''));
  		tpl = tpl.replace(matches[i],rep);
  	}                                     
  	return tpl;
  }
  alert(render("{a} is all that i've {b.a} {b.b} {b.c}", {a:"this", b:{a:"ever",b:"really",c:"needed"} }))

More micro-frameworks at http://microjs.com

return s(val).replace(re, function(t){

    if( t == '>' ) return '&gt';
    if( t == '<' ) return '&lt;';
    if( t == '&' ) return '&amp;';
    if( t == '"' ) return '&quot;';
    return t;