Help-Site Computer Manuals
  Algorithms & Data Structures   Programming Languages   Revision Control
  Cameras   Computers   Displays   Keyboards & Mice   Motherboards   Networking   Printers & Scanners   Storage
  Windows   Linux & Unix   Mac

a just-in-time compiler for HTML::Template





  use HTML::Template::JIT;


                                          jit_path => '/tmp/jit',


  $template->param(banana_count => 10);

  print $template->output();


This module provides a just-in-time compiler for HTML::Template. The module works in two phases:

When new() is called the module checks to see if it already has an up-to-date version of your template compiled. If it does it loads the compiled version and returns you a handle to call param() and output().

If your template needs to be compiled - either because it has changed or because it has never been compiled - then HTML::Template::JIT loads HTML::Template::JIT::Compiler which uses HTML::Template and Inline::C to compile your template to native machine instructions.

The compiled form is saved to disk in the jit_path directory and control returns to the Load phase.

This may sound a lot like the way HTML::Template's cache mode works but there are some significant differences:

  • The compilation phase takes a long time. Depending on your system it might take several seconds to compile a large template.

  • The resulting compiled template is much faster than a normal cached template. My benchmarks show HTML::Template::JIT, with a precompiled template, performing 4 to 8 times faster than HTML::Template in cache mode.

  • The resulting compiled template should use less memory than a normal cached template. Also, if all your templates are already compiled then you don't even have to load HTML::Template to use the templates!


Usage is the same as normal HTML::Template usage with a few addition new() options. The new options are:

This is the path that the module will use to store compiled modules. It needs to be both readable and writeable. This directory will slowly grow over time as templates are changed and recompiled so you might want to periodically clean it out. HTML::Template::JIT might get better at cleaning-up after itself in a future version.

This option tells the module to never compile templates. If it can't find a compiled version of a template then it croak()s rather than load HTML::Template::JIT::Compiler. You might want to use this option if you've precompiled your templates and want to make sure your users are never subjected to the lag of a compiler run.

Spits out a bunch of obscure debugging on STDERR. Note that you'll need to have a working version of the indent utility in your path to use this option. HTML::Template::JIT uses indent to make generated C code readable.

A special version of the HTML::Template print_to option is available to print output to stdout rather than accumulating in a variable. Set this option to 1 and output() will print the template contents directly to STDOUT. Defaults to 0.

NOTE: Using print_to_stdout will result in significant memory savings for large templates. However my testing shows a slight slowdown in overall performance compared to normal HTML::Template::JIT usage.



   cache (all modes)



   scalarref (and friends)

   arrayref  (and friends)


Included files are not checked for changes when checking a compiled template for freshness.

CODE-ref params are not supported.

The query() method is not supported.

It's not as fast as it could be - I'd like to see it reach somewhere around 10x faster than normal HTML::Template.

I wouldn't expect this module to work with UTF-8 unless your C compiler will accept UTF-8 inside C strings. I think that would be a violation of the C standard, so I think I need to do some work here instead.

As development progresses I hope to eventually address all of these limitations.






Sam Tregar <>



Copyright (C) 2001 Sam Tregar (



b) the ``Artistic License'' which comes with this module.


