The yz javascript django compiler is still in heavy development, currently it has support for only basic tags and filters, e.g. if tag, for loop tag, default filter, add filter, etc.
Here is a simple demo of some of its features: http://yz-demos.appspot.com/yz_djs_demo/

So Dojo’s DTL implementation has a lot of the features you mention, but there is at least one large philosophical difference, namely that Django’s templating language keeps code out of templates, and so Dojo’s implementation follows suit. As with Dojo’s existing templating system, the goal is to allow developers and designers to iterate on templates independent of each other and given how successful folks have been with the existing system, this seems to have been a good choice although I totally get that reasonable people can disagree on this one. Templating is hard, and hard to satisfy everyone with.

As for the features you list, I think all of them are available in Dojo in some way, although the syntax may not be as terse for some, and because the design of Dojo is layered, not everything comes through a single object. I’ll send you mail.

Regards

In the spirit of cooperation, I’ll cautiously list a few nice things about EJS. I’m not trying to be competitive. I hope that dojo can include a few of these (if it doesn’t already) in its toolkit.

EJS gives you a few options on where the template comes from:

Text: new EJS({text: ”})
Element: new EJS({element: document.getElementById(‘template’)})
File: new EJS({url: ‘/template.ejs’})

EJS templates can use 2 different magic tags or ${}.
EJS caches templates.
EJS can use JSLint for Debugging.
EJS has rails-like view helpers.

EJS also has many options for rendering:

Render and get back text: txt = new EJS({text: ”}).render({objectvalue: ‘anything you want’})

Update an element (I’m using prototype selector):
new EJS({text: ”}).update($$(‘div span.thinger ul’),{objectvalue: ‘anything you want’})

Update an element with the results from a JSON ajax request:
new EJS({url:’/todo.ejs’}).update(‘todo’,'/todo.json’)

I find debugging and loading from a file to be the most helpful features of EJS.

There’s also jMVC (http://blog.codeville.net/category/jmvc/) which is syntactically like EJS, but w/ less functionality. BUT, it allows continuations. If you have any other thoughts: j u s t i n at j u p i t e r dot c o m.

This templating language only needs you to dojo.require(“dojox.dtl”), at which point you can use it irrespective of the Dojo Widget System (aka: Dijit). Since (like all things in Dojo), it’s a layered design, you can use this templating anywhere, including in dojo.query() results. Check it out:

dojo.require(“dojox.dtl.ext-dojo.NodeList”);
dojo.query(“div > span.thinger > ul”).dtl(
“{{ objectvalue }}”,
{ objectvalue: ‘anything you want’ }
);

http://dojotoolkit.org/book/dojo-book-0-9/part-2-dijit/layout

Cheers,
PS (Biased fanboy, but what the hey :)

dojo.js is 23K. The new template system is 6K (gzipped), and both dojo.js and the dtl system are optimized to the hilt. Not only is Dojo not bloated, it’s downright tiny for the amazing features you get…and we give you serious optimization tools to keep your app light and fast.

Regards

It is why understanding the gap between professional tools (YUI/Dojo) and hobbyist tools (Prototype/jQuery) is so hard for people on either side of the equation.

Prototype / jQuery hobbyist tools? hahahaha.
Again people are mixing up the difference between a library and a toolkit. I must be pretty unprofessional to not want to weigh down my apps with YUI’s or Dojo’s bloat.