The following program was used to convert the scheme-faq from its original DocBook sources to the format used by this wiki.

 ;; Convert Scheme FAQ from DocBook to WiLiKi wiki format 
 ;; by Jorgen Schäfer and Anton van Straaten, July 2005 
 ; imports for PLT - all portable libraries 
 (require (lib "ssax.ss" "ssax") 
          (lib "sxml-match.ss" "sxml-match") 
          (lib "1.ss" "srfi") 
          (lib "13.ss" "srfi")) 
 (define base-path      "~/dev/schemefaq/") 
 (define site-url       "http://community.schemewiki.org/") 
 (define file-extension ".xml") 
 (define page-prefix    "scheme-faq-") 
 (define xref-targets 
   ;  file name      xref targets in file 
   '((general        lisp uses emacs) 
     (language       dottedapp dyntop) 
     (macros         hygienic portablemacro macroellipses nestedmacro multidefine macrodata) 
     (misc           sexp sicp) 
     (programming    cont) 
     (standards      standards R6RS reference srfi implementations libraries ffi java specialimpl debuggers))) 
 (define source-files (map car xref-targets)) 
 (define (pagename->url pagename) 
   (format "~a?~a~a" site-url page-prefix pagename)) 
 ; super-inefficient due to xref-targets list format; doesn't matter 
 (define (xref-id->url id) 
    (lambda (return) 
       (lambda (targets) 
         (if (memq id (cdr targets)) 
             (return (format "~a#~a" (pagename->url (car targets)) id)))) 
 (define (file->sxml filename) 
   (call-with-input-file (string-append base-path (symbol->string filename) file-extension) 
     (lambda (port) (ssax:xml->sxml port '())))) 
 ; compress-spaces : replaces sequences of multiple whitespace characters with a single space or newline 
 ; easier to do this with a native regex procedure, but this is portable 
 (define (compress-spaces s) 
      (lambda (c t) 
        (let ((c-prev (if (null? t) #\Z (car t)))) 
          (if (char-whitespace? c) 
              (if (char-whitespace? c-prev) 
                  (if (and (char=? c #\newline) 
                           (not (char=? c-prev #\newline))) 
                      (cons c (cdr t)) 
                  (cons c t)) 
              (cons c t)))) 
 ; compress-whitespace : string ->string 
 ; Replaces sequences of multiple whitespace characters with a single space, 
 ; and eliminates any leading or trailing whitespace. 
 (define (compress-whitespace s) 
      (lambda (c t) 
        (if (char-whitespace? c) 
            (if (or (null? t) 
                    (char-whitespace? (car t))) 
                (cons #\space t)) 
            (cons c t))) 
 ; convert-markup : match markup found in para bodies and convert to wiliki format 
 ; a para body is a list of strings and sxml. 
 (define (convert-markup body . compress?) 
   (let ((compress-spaces? (or (null? compress?) (car compress?)))) 
       (lambda (frag) 
         (sxml-match frag 
                     ; match cases ordered alphabetically 
                     [(application ,text) 
                      (format "{{{~a}}}" (compress-whitespace text))] 
                     [(b ,text) 
                      (format "'''~a'''" text)] 
                     [(blockquote (para ,text)) 
                      (format "~n<<<~n~a~n>>>~n" text)] 
                     [(citation ,text) 
                      (format "[~a]" (compress-spaces text))] 
                     [(citetitle ,text) 
                      (format "'''~a'''" text)] 
                     [(command ,text) 
                      (format "{{{~a}}}" (compress-spaces text))] 
                     [(emphasis ,text) 
                      (format "''~a''" text)] 
                     [(function ,text) 
                      (format "{{{~a}}}" (compress-spaces text))] 
                     [(informaltable (tgroup (thead (row (entry ,head1) (entry ,head2))) 
                                             (tbody (row (entry ,body1 ...) 
                                                         (entry ,body2 ...)) 
                      (string-append (format "|| '''~a''' || '''~a''' ||\n" head1 head2) 
                                     (format "|| ~a || ~a ||\n" 
                                             (convert-markup body1) 
                                             (convert-markup body2)) 
                     [(itemizedlist (listitem (para ,text ...)) ...) 
                      (string-append (format "- ~a\n" (convert-body text)) 
                         (title ,title ...) 
                         (para ,body ...) 
                       (format ":~a:~n~a\n" (convert-header title) 
                               (string-append (compress-whitespace (convert-para body)) 
                     [(literal ,text) 
                      (format "{{{~a}}}" (compress-whitespace text))] 
                     [(programlisting ,code ...) 
                      (format "~n{{{scheme~n~a~n}}}~n" (convert-markup code #f))] ; code may have markup, but don't compress spaces 
                     [(quote ,text ...) 
                      (format "\"~a\"" (convert-markup text))] 
                     [(remark ,text) 
                      (format "'''~a'''" (compress-whitespace text))] 
                     ; only occurs in program-listing; wiki doesn't support in conjunction with scheme highlighting 
                     [(replaceable ,text) 
                     [(row (entry (application ,name)) (entry (ulink (@ (url ,url))))) 
                      (format "- [~a ~a]~n" url name)] 
                     [(simplelist (member ,text ...) ...) 
                       (format "- ~a~n" (convert-para text)) 
                     [(superscript ,text) 
                      (format "^~a" text)] 
                     [(ulink (@ (url ,url)) ,body ...) 
                      (let ((body (convert-body body))) 
                        (if body 
                            (format "[~a ~a]" url body) 
                            (format "[~a]" url)))] 
                     [(xref (@ (linkend ,id))) 
                      (format "[~a here]" (xref-id->url (string->symbol id)))] 
                       (if (string? other) 
                           (if compress-spaces? 
                               (compress-spaces other) 
                               (format "~a" other)) 
                             (printf "Markup not handled: ~a~n" other) 
                             (format "~a" other)))])) 
 (define (convert-body frags) 
   (if (null? frags) 
       (convert-markup frags))) 
 (define (convert-para body) 
    (convert-markup body) 
 (define (convert-header body) 
    (convert-markup body))) 
 ; extract-para-bodies : extract bodies from paras 
 ; Converts a list of paras to a list of body lists 
 ; each body list is a list of text or sxml values 
 (define (extract-para-bodies paras) 
    (lambda (sxml) 
      (sxml-match sxml 
        [(para ,body ...) body] 
        [(remark ,body ...) (cons "WTF is this doing here? " body)] 
        [,else (error "expected PARA - found: " else)])) 
 ; convert-using : convert the specified paras using proc 
 ; Extracts bodies from the specified paras, converts each body with proc, 
 ; and turns the resulting list of strings into a single string 
 (define (convert-using proc paras) 
   (apply string-append (map proc (extract-para-bodies paras)))) 
 (define (convert-qanda sxml) 
   (sxml-match sxml 
       (question (@ (id (,id #f))) ,question ...) 
       (answer ,answer ...)) 
      (format "~a*** ~a~n~a~n" 
              (if id (format "[[$$label ~a]]~n" id) "") 
              (convert-using convert-header question) ; probably overkill for questions, but works 
              (convert-using convert-para answer))] 
     ; match question without answer 
       (question (@ (id (,id #f))) ,question ...)) 
      (format "~a*** ~a~n" 
              (if id (format "[[$$label ~a]]~n" id) "") 
              (convert-using convert-header question))])) ; probably overkill for questions, but works 
 (define (sxml->faq sxml) 
   (sxml-match sxml 
       (title ,title) 
       (format "** ~a~n~n" title) 
       (convert-qanda entry) 
     [,else (error "expected QANDADIV - found" else)])) 
 (define (faq-page pagename) 
   (printf "Processing ~a~n" pagename) 
    `("* Scheme Frequently Asked Questions\n" 
      "The material on this page is licensed under the GNU Free Documentation License; either version 2, or (at your option) any later version. See [[scheme-faq-license]] for more information.\n\n" 
      ; link to all pages except current one 
          (lambda (page) 
            (if (eq? page pagename) 
                (list " | " (format "'''~a'''" page)) 
                (list " | " (format "[~a ~a]"  (pagename->url page) page)))) 
      ,@(sxml->faq (cadr (file->sxml pagename))) 
 (define faq-sources (map faq-page source-files)) 
 (display (list-ref faq-sources 6)) ; display a page