xmltools-tm.xtm | Filter | Export | Statistics | Query

description

[No name] (1)

  • description

Topics (250)

 

Subject Identifiers (1)

Occurrences of this Type (250)

  • 4Suite is a collection of XML processing tools based on the Python XML-SIG package. It contains a complete XSLT implementation, an XPath implementation, a DOM implementation (level 1 and level 2), a persistent DOM implementation that stores documents in an object database, an RDF toolkit with persistence and schema support, an XPointer implementation an XLink processor, an XInclude processor, and an XUpdate processor. (4Suite)
  • ARP is an RDF parser (the name is short for Another RDF Parser) that parses RDF XML documents into RDF triples. ARP is designed to be used as an RDF parser in Jena, but can also be used separately. (ARP)
  • AdvXMLParser is a small and simple to use non-validating XML parser written in C++, which accepts a subset of the XML specification. (The DOCTYPE declaration is not accepted.) The parser builds a tree structure and can be used to generate XML. (AdvXMLParser)
  • Amaya is the W3C testbed browser, and is an HTML and XHTML browser (and editing tool) with CSS support. It supports the MathML 2.0 XML DTD and can edit and display presentational MathML graphically; Amaya can also display some SVG. There is support for simple XLinks. Amaya can read HTML documents written in XML, and save HTML documents as XHTML. (Amaya)
  • Arabica provides SAX 2.0 support for a number of C and C++ XML parsers as well as a DOM level 2 implementation on top of the SAX 2.0 interfaces. (Arabica)
  • BML is a binary representation of XML (Binary Markup Language), and also a set of tools for working with BML. The BML tools have their own event-based and tree-based APIs similar to SAX and the DOM. BML can also convert back and forth between XML and BML representations of documents. (BML)
  • CL-XML is an XML parser written in Common Lisp. The parser is validating, and contains a DOM implementation as well as object models representing the infoset and the XPath data model. It also provides access to DTD information, and supports XML namespaces, even in DTDs. The parser also contains an XPath module which can evaluate XPath expressions written in XPath or S-expression syntax against DOM trees. CL-XML also supports XML Query. (CL-XML)
  • CLOCC is an open source library of useful Common Lisp modules, which contains a non-validating XML parser known as xml.lisp. This parser originally came from the CLLIB library. (xml.lisp)
  • Castor is a XML data binding framework with support for mapping both between XML and Java objects and between Java objects and relational databases. This makes it very suitable for loading XML into Java applications built on relational databases. Castor uses Java reflection to figure out how to map Java objects to XML, and to reverse the process. A mapping file can also be used to describe the mapping, but it cannot cover all cases. Castor can make use of an XML Schema to improve the mapping. (Castor)
  • CenterPoint/XML is a SAX 2.0 and DOM 1.0 2.0 implementation built on top of expat. (CenterPoint/XML)
  • Cocoon is a XML publishing framework that can be used to publish XML on the web as HTML. It is designed to be performant and flexible, using SAX pipelines and XSLT stylesheets. Over the years Cocoon has grown to become a large and powerful tool with support for many kinds of formats and data sources. (Cocoon)
  • Cooktop is an XML editor which shows a plain-text view of the XML documents being edited. It does syntax colouring of XML documents, DTDs, and XSLT stylesheets. It can check for well-formedness and validate documents, pretty-print via Tidy, and test XSLT stylesheets and XPath expressions inside the editor. (Cooktop)
  • Cost is an old and well-known programming tool for writing SGML (and now XML) transformations in tcl. It can use both SP and expat as parsers. (Cost)
  • DB2XML is a tool for generating XML from database queries. It is a GUI-driven application written in Java, but can also be used as a servlet and as a command-line application. The XML generated is configurable, and metadata (types etc) can optionally be included, dates can be customized and currency representation can be localized. The generated XML can be processed with an XSLT stylesheet. DB2XML uses JAXP to get parsers and XSLT engines. (DB2XML)
  • DSC is a DSSSL engine built on James Clark's SP SGML parser. It implements the DSSSL transformation language, but not the style language, and also contains a nearly complete Scheme implementation. DSC also provides very good error messages, making it useful as a debugging tool. (DSC)
  • DSD is an XML schema language developed by researchers at AT&T and the University of Aarhus. The developers claim that it is more powerful and readable than XML Schemas or DTDs. The DSD Prototype Processor is a prototype implementation of the DSD schema language, which can also convert DTDs to DSD schemas. (DSD Processor)
  • DT4DTD supports schema-compatible datatyping in existing SAX or DOM implementations. After some modest 'wiring' it makes a set of routines available to the developer for use in accessing and validating datatypes such as numbers and dates in element and attribute information in forms other than simple strings. An extensible registry of types also permits developers to build libraries of custom datatypes that can be reused in various implementations. (DT4DTD)
  • DTD2RELAX converts a DTD into a RELAX schema module. The converter has both a command-line and a GUI interface. It uses XML4J 1.1.16 to parse the DTD. Output can be produced as SAX events. (DTD2RELAX)
  • DTDDoc is a Java tool for creating HTML documentation of XML DTDs based on Javadoc-like documentation embedded in comments in the DTD. (DTDDoc)
  • DTDInst can convert DTDs into an XML DTD developed especially for this tool that represents DTDs in XML syntax. DTDInst handles parameter entities well, and can even detect the semantic intent behind some parameter entities and convert these into XML elements representing higher-level semantic constructs. (DTDInst)
  • DTDParse is a Perl module that can parse a DTD into an in-memory structure. This structure can then be used in various kinds of programs that need DTD information. It comes with several scripts that can produce DTD documentation using this module. (DTDParse)
  • DTDParser is a Java module for parsing XML DTDs separately from any XML document. The parser can parse from any kind of stream and builds an object structure representing the DTD. This structure can then be accessed to extract information about the DTD and also be modified. (DTDParser)
  • Data Descriptors by Example (also known as DDbE) is a component library that can be used to automatically generate an XML DTD or XML Schema (Oct 2000 CR) from a set of document instances. DDbE is customizable, but does not need to be customized. (Data Descriptors by Example)
  • Digester is a simple XML data binding framework designed to make it easy to read data from XML configuration files to Java objects. It uses a configuration file defining mapping rules described using patterns that are designed to be implementable on top of SAX, while looking like XPath. If these patterns are not sufficient you can plug in the pattern engine of your choice. (Digester)
  • Emacs is easily one of the most powerful (if not the most powerful) text editors in the world. It has an internal Lisp programming language, which means that it can be easily extended, and as a consequence Emacs has suppot for most programming languages ever invented, as well as a web browser with CSS support and a world-class news and mail reader. (PSGML)
  • Emilé is an XML editor that reads the DTD to provide short-cuts for the user during editing. Emilé can export documents as HTML. (Emilé)
  • Engines that support the XSL Transformations specification. (XSLT engines)
  • Engines that support the XSL formatting objects specification. (XSL engines)
  • FOA (short for Formatting Objects Authoring tool) is a graphical XSLT stylesheet editor designed for editing stylesheets that produce XSL-FO output. When using FOA you provide it with input XML files that are already written, and use FOA to create the XSLT stylesheet that will transform the files into XSL-FO documents. (FOA)
  • FOP is a Java application that takes an XML document conforming to the XSL:FO 2000-11-21 Candidate Recommendation and produces PDF output. It also supports some parts of SVG. FOP can be used with any SAX 2.0 parser to produce PDF from XSL. FOP can be invoked from the command line and read from a file, or it can be given a DOM document or a SAX DocumentHandler at run-time. (FOP)
  • FirstSTEP EXML is a tool that can convert from product data declarations in the EXPRESS language (part of the STEP standard for product data) into XML DTDs. STEP data can then be represented in XML using this DTD. (FirstSTEP EXML)
  • Flute is a CSS2 parser written in Java that implements SAC. SAC is a standard event-based API for CSS parsers, closely modelled on the SAX API for XML parsers. This parser was earlier incorrectly listed here under the name SAC. (Flute)
  • Fxgrep is a command-line tool for querying an XML document. Queries can be specified either in an XPath-like pattern language or using a more verbose (but also more powerful) grammar language. It is based on the fxp parser. (Fxgrep)
  • Fxt is an XML processing tool that combines XML pattern matching capabilities with the Standard ML programming language to create a language for XML processing. Fxt uses Fxp for XML parsing and Fxgrep for pattern matching. (Fxt)
  • GNOWSYS is a topic map engine developed using Zope. It is quite experimental, and does not yet support import from any topic map syntax. (GNOWSYS)
  • GPS is a general implementation of the grove data model (from the HyTime ISO-standard). It implements both groves and property sets, in two different implementations. One is an in-memory structure, the other uses the ZODB object database for persistence. (GPS)
  • Gdome is a DOM 2.0 implementation currently in development as part of the GNOME project. It is written to be used with the libxml parser. This implementation is currently experimental. (Gdome)
  • GenDoc is an open source XML editor for data-oriented applications which has a tree-view and a styled view. It has a plugin API that allows the editing of some elements to be customized for specific DTDs, and also allows publishing actions to be executed from the editor. GenDoc is based on the now defunct Merlot project, and was formerly known as GenDiapo. (GenDiapo)
  • General software packages for making XML-aware applications of some form. (XML middleware)
  • Gobo Eiffel is a collection of Eiffel components, among which can be found the expat XML parser wrapped into the Eiffel programming language. (Eiffel is an industrial-strength object-oriented language with many features beyond what Java and C++ offer.) There is also a tree-building package on top of the wrapped expat parser. (Gobo Eiffel)
  • HTML-Kit is an extensible Windows text editor, with special support for editing XML documents, CSS stylesheets and, through extensions, also for editing XSLT stylesheets. (HTML-Kit)
  • HXML is a non-validating XML parser written in Haskell, with emphasis on space-efficiency through lazy evaluation. It is intended to be usable as a drop-in replacement for HaXml. It is currently of alpha quality. (HXML)
  • HaXml is a collection of libraries for using XML in Haskell. This includes a non-validating XML parser, an HTML parser, a library for transforming XML documents (and generating HTML) and special modules for building Haskell data structures from XML documents and dumping them back out as XML. HaXml supports Unicode if the Haskell compiler does. (HaXml)
  • IBM techexplorer is a plug-in for Netscape and Microsoft Internet Explorer that can be used to view TeX and MathML documents. It supports all of MathML 1.01, but is not a general XML browser. (IBM techexplorer)
  • Is based on the expat parser built into PHP, but uses it to build a tree representation of XML documents that can be modified and written back to XML. The tree API is not DOM, but deliberately designed to be easier to use. (gogoXML)
  • JDOM is an API for representing the XML document tree structure similar to the DOM, but much simpler and designed specifically for Java using the collections API. JDOM structures can be built from XML files, DOM trees and SAX events and can be converted to the same. (JDOM)
  • JEDI is a general tool for converting various kinds of text files (plain text, HTML, ...) into a structured form, which can be XML. It does this using an advanced rule language, and even has features for following HTML links and filling out forms. It can also be extended with Java code. (JEDI)
  • Jade is James Clark's excellent DSSSL engine, which is really a general SGML tool for conversion from SGML to other SGML DTDs or to output formats like RTF and TeX. Jade can process XML documents and can also output XML. Jade uses SP to parse the SGML/XML input. (Jade)
  • Java HTML Tidy is a reimplementation of Tidy in Java. JTidy, as it is also known, can parse non-conforming HTML documents into a DOM tree and convert them to valid HTML. (JTidy)
  • Java/XML Quick is a tool for mapping between Java object models and XML documents. Quick has a markup language for describing Java object models, and from this it can generate serialization and deserialization code that can move data back and forth between XML and Java objects. The Java code is generated by Quick, and the XML representation is also defined by Quick from the object model definition. (Java/XML Quick)
  • JaxMe is an XML data binding framework based on SAX 2.0, which makes it fast and memory-efficient. Based on a JaxMe schema (which shares a subset with W3C XML Schema) JaxMe generates Java classes for working with the XML data and loading into Java objects, EJB objects, and storing it in an RDBMS or writing it back out when modified. (JaxMe)
  • Jaxen is an XPath implementation written in Java, which can parse XPath expressions, and evaluate them against XML tree representation. Jaxen currently supports DOM, dom4j, EXML, and JDOM. (Jaxen)
  • Jena implements an API that represents RDF models, that is, the RDF data model. With this API you can access RDF data in-memory, change it, navigate over it, store it in an RDBMS, and so on. Jena uses ARP to parse RDF documents, and can also export RDF models back to XML documents. (Jena)
  • JiBX is an XML data binding framework which simplifies transferring data between domain-specific object structures and input XML documents. The binding is specified using a binding definition document, and JiBX uses a binding compiler to compile the definitions into Java bytecode for efficiency. JiBX is designed for high performance. (JiBX)
  • Jing is a validator that allows XML documents to be validated against RELAX NG schemas. Jing is implemented as a SAX 2.0 ContentHandler, and so can be used with any SAX 2.0-compliant parser. (Jing)
  • LT PyXML is a Python interface to the LT XML package parser and API, which provides Python with access to a fast validating parser and a powerful API. (LT PyXML)
  • LTXML is a set of tools (including a parser) written in portable C. Included are: a program to strip out all XML markup, an XML normalizer (mainly useful for well-formedness checking), an ESIS outputter, an element occurrence counter, a tokenizer, a down-translation tool, a grep tool, a sorting tool, some linking tools as well as some other minor utilities. The executables are mainly intended to be pipelined to produce various kinds of output, but provide a C API that can be used to extend them for other purposes. (LTXML)
  • Lark was one of the two first XML parsers to appear, written by XML spec co-author Tim Bray, but was non-validating for a long time. Tim Bray has now added Larval, a validating parser, to the package. (Lark)
  • LiveDTD parses XML DTDs and generates HTML files from the DTDs with cross-links to element and parameter entity definitions. These HTML files can then be used as documentation, thanks to the links. (LiveDTD)
  • MDC-XSL is an XSLT engine written in C++ as part of the Circare product developed by Minoru Development Corporation. The engine is open source and supports a subset of the XSLT specification. The engine has both an API and a command-line interface. (MDC-XSL)
  • Majix is an RTF-to-XML converter written entirely in Java. It can handle RTF styles and also lets you customize it to fit your own XML DTDs. (Majix)
  • MetaMorphosis is a tree-based XML transformation tool that can be used to convert between SGML/XML applications, to publishing formats etc. MetaMorphosis has an architecture where several parsers and output generators are available (and more can be written in Visual Basic or C++ and plugged in). (MetaMorphosis)
  • Non-XML converters (or "N-converters") are designed for converting from non-XML representations (typically word-processing formats) to XML. (General N-converters)
  • OpenJade is a variant of James Clark's Jade DSSSL engine that has been extended and modified by an open source project. (OpenJade)
  • OpenSP is a variant of James Clark's SP SGML parser that has been extended and modified by an open source project. It supports more of SGML open catalogs, more of annex K to the standard, is internationalized among other things. (OpenSP)
  • Ozone is an open source OODBMS written in Java, on top of which several XML tools have been built, loosely grouped under the name infozone. Prowler is a persistent DOM level 1 implementation which stores its nodes in Ozone. It also supports XPath. RelDOM supports storing XML documents persistently in an RDBMS. Lexus is an implementation of the XML Update language on top of Prowler. Schemox is a tool for generating input form for XML data. (infozone)
  • PECEL is an XML data entry tool geared towards data applications more than document applications. It is tree-based, and uses a DTD to guide the user during document creation. PECEL also has a template function for creating document templates. PECEL uses XML4J for parsing. (PECEL)
  • PXP is a complete validating XML parser written in Objective Caml, a functional programming language in the ML family with OO features. PXP has some advanced features for building customized XML document trees and also provides access to DTD information. It supports Unicode and can read documents in many different encodings. (PXP)
  • PXSLServlet is a Java servlet that can be used to publish relational database data as HTML using XSLT stylesheets. PXSLServlet does caching of control information (stylesheets, config files etc) and pooling of connections, and so is relatively efficient. It uses XT for XSLT transformations. (PXSLServlet)
  • PassiveTeX is a TeX implementation of the XSL November 2000 WD and MathML which reads XML documents containing XSL formatting objects and MathML elements and uses LaTeX to produce formatted output. This can be used to produce well-formatted PDF, DVI or PostScript, and even supports bookmarks in the PDF output. (PassiveTeX)
  • PatML is a rule-based specification language for transforming XML, for example to HTML. PatML allows the rules to trigger Java code. The system consists of three Java beans, each suitable for reuse in a larger system. (PatML)
  • Pathan is an XPath engine built on top of the Xerces C++ DOM Parser. Pathan has full support for XPath. (Pathan)
  • Piccolo is a small high-performance XML parser for Java without validation, but with support for XML Namespaces. Piccolo have come out of several tests as the fastest XML parser tested, despite being created using automatic parser generators. (Piccolo)
  • Protégé is a very advanced knowledge-based framework for developing domain-specific systems. It has been developed and used by the medical informatics community for years and has lately been extended with support for RDF. So Protégé does much much more, but can also be used for generating editors for specific RDF applications. It understands both RDF and RDF schemas. (Protégé 2000)
  • Publishing converters convert XML documents from XML to some publishing format suitable for distribution. (Publishing converters)
  • PyTREX is an implementation of the TREX schema language based on Pyexpat. It can be used to validate XML documents against TREX schemas. (PyTREX)
  • Pyana wraps the Xalan-C++ XSLT engine as a Python module, making it available to Python programs. (Pyana)
  • Pyxie is a powerful XML processing library written in Python which can be used to develop XML processing software which is event-driven, tree-based or event-driven with tree access. Pyxie requires the Python XML package. (Pyxie)
  • QuiP is an implementation of the April 2002 XQuery working draft, which can be used to query both XML documents on disk as well as XML documents stored in a database. QuiP has a graphical user interface which is used to write queries and see the query result. This is the only interface to QuiP, which is thus mostly useful as a learning tool. (QuiP)
  • RDF-Parser is an RDF parser that reads RDF files into an RDF data structure. It supports all of the RDF model and syntax recommendation except for EachPrefix. Registration is required for download. (RDF-Parser)
  • RDFDB is a database that supports the RDF data model directly. It can load data from files or data can be inserted using the database API. It also supports an SQL-like query language. (RDFDB)
  • REXP is an XSL:fo to PDF file converter, based on the source of FOP 0.9.2. It supports a bit more of XSL than FOP does. A tiny bit of support for SVG is also there, and there will probably be more in the future. (REXP)
  • RTF2XML (formerly known as RTF2SGML) reads RTF files and converts them to an XML document corresponding to an XML DTD that comes with RTF2XML. RTF2XML supports Unicode RTF. RTF2XML is written in OmniMark and so requires OmniMark to run. (RTF2XML)
  • RXP is a thread-safe validating parser written in C. It is distributed as C source and must be compiled before use. It supports Unicode and XML namespaces and comes with a command-line application that prints out the parsed document. It provides a non-DOM tree interface to the parsed document. RXP is also available as part of the LTXML package. RXP also supports the ISO 8859-1 to ISO 8859-9 character encodings. (RXP)
  • Raptor is an RDF parser written in C, designed to be used from the Redland RDF database system, but can also be used separately. It does not do XML parsing itself, but can use either expat or libxml to do XML parsing. Raptor is designed to be fast and robust, but at the moment it is of beta quality. (Raptor)
  • Redfoot is a framework for developing RDF-based applications, consisting of an RDF database with a query API, an RDF parser and serializer and a web interface for viewing and editing RDF. It also intends to support inter-database communications. (Redfoot)
  • Relaxer is a Java tool that can read a RELAX schema and generates a set of Java classes that can represent the objects described by the schema in memory or in an RDBMS. Relaxer uses Xerces as its XML parser, but also supports SAX 2.0 and supports XML Namespaces and XBase. (Relaxer)
  • Rhythmyx XSpLit claims to be able to automatically generate an XML DTD and an XSLT stylesheet from a sample HTML document. The XSLT stylesheet can then be combined with XML documents that conform to the XML DTD to produce HTML pages with the same design as the original, but with new content. (Rhythmyx XSpLit)
  • SAX is a simple event-based API for XML parsers. It is not an official standard, since it was developed by the participants of the xml-dev mailing list instead of a standards body. However, SAX is very much a de facto standard, since it is supported by most XML parsers and is used by lots of applications (SAX2)
  • SAXON is a Java framework for processing XML documents optimized for XML to XML/SGML/HTML conversions. Essentially, it is an XSLT engine (1.0 recommendation) which can also be used as a Java development framework. The XSLT implementation is fast, fully conformant and provides many useful extensions. Through its API Java and XSLT code can be combined. (SAXON)
  • SAXPath is an event-based API for XPath parsers, that is, for parsers which parse XPath expressions. SAXPath is intended to be for XPath what SAX is for XML. Note that the SAXPath package only parses XPath expressions; it does not evaluate them, or even provide an object structure for representing them once they have been parsed. (SAXPath)
  • SCEW, Simple C Expat Wrapper, is a tree API to XML documents built on top of expat. SCEW lets you modify the trees once built, and also gives you access to the expat parser underneath to give full flexibility. (SCEW)
  • SGMLSpm is a Perl script that reads ESIS output (from parsers like SP) and offers an event-based interface to the parser. As long as the parser can parse XML this also works for XML. (SGMLSpm)
  • SP is an SGML/XML parser, and is fast, complete, highly conformant and very stable. SP has been the parser of choice for most of the SGML community for many years and has been embedded in lots of other applications. SP supports architectural forms as well as SGML Open catalogs. (SP)
  • Schematron.NET is a C# implementation of the Schematron schema language instead of the usual approach, which is to implement the Schematron in XSLT. Reports indicate that Schematron.NET is substantially faster than XSLT implementations of Schematron. (Schematron.NET)
  • SemanText is a topic map engine and editor with inferencing capabilities that enable it to automatically generate new knowledge and mine various forms of source data for new information. SemanText is built on top of tmproc and provides a graphical user interface. (SemanText)
  • Simkin is a scripting language that can be embedded in XML documents to store behaviour in the documents. It is intended to be used in XML somewhat like JavaScript is used in HTML. There is a Java interpreter for Simkin as well as a C++ one, allowing Simkin to be used with both languages. (Simkin)
  • Skyron simplifies reading XML data into Python objects though a "recipe" file, which describes the actions to be taken upon encountering specific pieces of XML data. The recipe files can have Python code and calls to Python methods interspersed, which allows Skyron to be used for XML data binding, but also for creating interpreters for active XML languages. (Skyron)
  • Software for easily binding XML documents to programming language objects for serialization and deserialization. (Data binding engines)
  • Software for validating XML documents by other means than DTDs. (XML validators)
  • SwiX is an XML validator and normalization tool, which can be used to validate XML documents and also to normalize them. It can also parse and and normalize DTDs. (SwiX)
  • Systems for persistently storing XML documents and providing access to their structure and individual parts. Storing XML documents as blobs does not qualify. (XML document database systems)
  • TM4J is an implementation of the XTM topic map standard. TM4J can read in topic maps encoded in XML using SAX 1.0 or the DOM and also generate XML topic maps. It provides a general API for manipulating topic maps, but no functionality directed towards end-users. (TM4J)
  • TMTab is a topic map engine and editor implemented as a Protege plug-in, which allows ontologies to be created and edited using the Protege editing interface. TMTab bases its topic map capabilities on TM4J. (TMTab)
  • TagSoup is an HTML parser which can parse HTML as it is found on the web (and not just valid HTML) and make it available through a SAX 2.0 interface. It attempts to emulate the behaviour of web browsers by correctly nesting elements, inferring missing tags, and adding default attribute values, and it never signals syntax errors. (TagSoup)
  • TclDOM is a 100% Tcl implementation of the DOM 1.0 that also include C wrappers for the libxml DOM implementation. The aim is to create a standard Tcl version of the DOM to be used with any DOM implementation/parser. (TclDOM)
  • TclExpat is the expat C XML parser wrapped as a Tcl module. Version 1.1 uses the final 1.0 version of expat, which supports XML namespaces. (TclExpat)
  • TclXML wraps the libxslt XSLT engine as a Tcl module. It is possible to use Tcl to implement XSLT extension elements and XPath extension functions. (TclXSLT)
  • The CyberNeko HTML parser is an HTML parser built on the native interface of the Xerces XML parser. It adds missing parent elements, automatically closes elements, and can handle mismatched end tags. (CyberNeko HTML Parser)
  • The DOM Parser is a SAX 1.0-compliant parser that turns a DOM Document into a SAX event stream, instead of parsing an XML document. (DOMParser)
  • The DTD Parser can parse an internal or external subset in the form of a SAX InputSource and build a structure of non-standard objects representing the DTD, which can then be used to explore or modify the DTD. The package can also be used to convert between DTDs and the DDML schema language. (DTD Parser)
  • The Docuverse DOM SDK is a Java implementation of the Document Object Model (DOM 1.0) that can use any SAX 1.0 to build the DOM document tree. The DOM builder part of the implementation is very general, so one can extend it to use other kinds of builders as well. (SAXDOM)
  • The GMD-IPSI XQL engine is a Java implementation of the W3C-QL'98 workshop paper syntax of XQL, based on a persistent thread-safe DOM implementation. The PDOM can be built from XML documents using a SAX 1.0 parser. (GMD-IPSI XQL Engine)
  • The ICS-FORTH VRP can parse RDF documents and validate them against an RDF Schema. It is intended to be embedded in other software as a library. (ICS-FORTH Validating RDF Parser)
  • The ParserFilters are classes that wrap SAX 1.0 parsers in classes that provide SAX 1.0 parser interfaces. This allows for the development of extra services layered on top of ordinary parsers. (Parser Filters)
  • The Perl libxml includes the Perl version of SAX 1.0, PerlSAX (a special Perl version of SAX), a SAX driver for XML::Parser, a SAX driver that can read ESIS output from SP and XML::Grove integration code. (Perl libxml)
  • The Python XML package is a package of various Python XML tools that has been put together by the Python XML Special Interest Group, a group of volunteers led by Andrew M. Kuchling, for the convenience of Python XML developers. (Python XML package)
  • The S-Link-S Editor is an RDF editor. It is currently of alpha quality. (S-Link-S Editor)
  • The SAXExpat package is a wrapper around the expat XML parser that makes it possible to use it within Delphi and Kylix. It also includes an interface for generating XML documents from programs. (SAXExpat)
  • The SKYRiX Libraries contains a SAX 2.0 translation to Objective C, and contains SAX drivers for a number of XML parsers. One is the CoreFoundation XML parser that is part of MacOS X, another is for the libxml parser, a third for expat, and there are some more. There is also a DOM implementation built on top of the SAX API. (SKYRiX Libraries for XML Processing)
  • The Sablotron is an XSLT processor written in C++ (as open source). The goal is to make the processor fast, compact and portable. The Sablotron has both a command-line and an API interface. Not all features of XSLT are currently implemented. The Sablotron uses expat for XML parsing. (Sablotron)
  • The Schematron is an innovative schema language for XML documents radically different from existing approaches. It can be used as a friendly validation language and for automatically generating external annotation (links, RDF, perhaps Topic Maps). Because it uses paths rather than grammars, it can be used to assert many constraints that cannot be expressed by DTDs or XML Schemas. (Schematron)
  • The Sun Multi-Schema Validator Schematron Add-on extends the Multi-Schema Validator to support validation of XML documents against RELAX-NG schemas annotated with Schematron schemas. This provides very powerful schema capabilities combined with very good error messages. (Sun MSV Schematron Add-on)
  • The Sun Multi-Schema Validator is an XML validator that can validate XML documents against schemas written in several different schema languages. At the moment it supports DTDs, RELAX-NG, RELAX, TREX, and a subset of XML Schema. (Sun Multi-Schema Validator)
  • The Sun RELAX-NG converter can convert schemas from many different schema languages to RELAX-NG. It is based on Sun Multi-Schema Validator, and supports DTDs, RELAX, TREX, and XML Schema. (Sun RELAX-NG Converter)
  • The Sun XML Datatype Library is an implementation of XML Schema, part 2 for use in applications that need support for the data typing capabilities of XML Schema. (XML Datatypes Library)
  • The Sun XML Instance Generator can generate random XML instances from schemas written in several different schema languages. These instances can then be used for automated testing of applications, both load-testing and other kinds of testing. At the moment it supports DTDs, RELAX-NG, RELAX, TREX, and a subset of XML Schema. The Instance Generator is based on the Multi-Schema Validator. (XML Instance Generator)
  • The Unicorn XSLT Processor is an XSLT engine implemented in C++. The release is a binary-only release, and the processor only has a command-line interface. The underlying parser does not resolve external entities, and only UTF-8 and UTF-16 are supported. (Unicorn XSLT Processor)
  • The XFA Scripting System is an interpreter for an XML-based scripting language. XFA uses an XML-based syntax with two variants: restricted (XML-compliant) and extended (non-compliant). Using XFA program code can be integrated with document contents using the same syntax. (XFA Scripting System)
  • The XML Bean suite consists of seven XML beans: DOMGenerator, DTDSourceView, XMLAttributeView, XMLChildren, XMLSourceView, XMLTokenizer, XMLTreeView. (XML Bean Suite)
  • The XML Entity and URI Resolvers are a set of Java classes for parsing SGML Open catalog files and XML Catalog files into a data structure. Part of the classes are also a SAX EntityResolver and a JAXP URIResolver which can be used to add catalog support to XML parsers. (XML Entity and URI Resolvers)
  • The XML Security Suite includes features such as digital signatures, encryption, and access control. It implements the XML Signature and XML Encryption W3C specifications. (XML Security Suite)
  • This XML parser has implementations in both Java and C++ and uses a rather unusual API design in that it does not have a tree-based or event-based API, but rather a pull API where the document is pulled as individual tokens from the parser. The parser is very small and it is also claimed to be fast. (XML Pull Parser)
  • This is James Clark's expat C parser wrapped as a Perl module that can be compiled into the Perl interpreter. It supports XML namespaces. (XML::Parser)
  • This is a collection of various Java XML utilities, including an improved version of the Ælfred XML parser known as Ælfred2 with SAX 2.0 support, a DOM 2.0 implementation, and a JAXP implementation. (GNU JAXP)
  • This is a validating XML parser written entirely in tcl. The parser offers both event-based and tree-based interfaces, and with Tcl 8.1 it supports Unicode. (TclXML)
  • This is a validating XML parser written in Delphi that parses XML documents into a DOM element tree that can then be modified and traversed. The component also allows programs to build DOM trees and write them out as an XML document. The parser supports both 8-bit and 16-bit encodings. (XML Parser Component for Delphi)
  • This is an Emacs major mode for editing DTDs. It does syntax colouring, has some convenience macros for inserting commonly-typed constructs as well as ETAGS integration. It is a stand-alone mode, but works well together with PSGML. (tdtd)
  • This is two OmniMark scripts that convert XML DTDs to DDML schema documents. (xml2ddml)
  • This is version 5 of Netscape Navigator, which can display XML documents with CSS style. It also has some support for MathML. Please note that this is a beta release. (Mozilla)
  • This module wraps the expat parser (version 1.2) for access from within the Ruby interpreter. (Ruby is an object-oriented scripting language with similarities to Perl.) It also has a DOM 1.0 implementation and XPointer support. (Expat Module for Ruby)
  • This tool can parse CSS2 stylesheets into a DOM2 structure and also supports the SAC API. (CSS2 Parser)
  • This tool converts DTDs into XML Schema instances. It knows about parameter entites in the DTD and translates those into equivalent constructs in the XML Schemas, which makes the resulting schemas much smaller than they would otherwise have been. (dtd2xs)
  • This tool validates XML documents against a TREX schema, and can use any SAX 1.0 or 2.0 parser. There is a command-line interface. (Sample TREX implementation)
  • Tidy is a tool that can read your XML and HTML markup and detect and to some extent also fix errors in it. This can be used to clean up bad HTML and XML and also to convert from poor HTML to XML. Tidy can also pretty-print your markup, and has special features for dealing with the HTML produced by MS Word '97 and 2000. It is to some extent also aware of ASP, JSP and PHP directives and will ignore these. (Tidy)
  • TmTk is a generic topic map toolkit written in C, with a Python wrapper. It can import and export the XTM 1.0 syntax, can store topic maps in a native persistent backend, and has a built-in query language. The toolkit was previously known as GWTK. (GWTK)
  • Tony is a lightweight XML parser written in the functional programming language Objective CAML. It claims to be much smaller than most other XML parsers, but is not complete. Tony comes with an advanced configurable pretty-printer. (Tony)
  • Tools for creating, modifying and documenting DTDs, XSL style sheets etc. (Control information development)
  • Tools for electronic delivery and display of XML documents. (Electronic delivery)
  • Tools for interactive creation, modification and composition of XML documents. (Editing and composition)
  • Tools for scripted creation and modification of XML documents. (Conversion)
  • Tools for supporting document management, such as document databases and search engines. (Document Storage and Management)
  • Tools whose purpose is to generate XML according to a specific document type from non-XML source documents. (Specific N-converters)
  • Trang is a schema converter which can convert schemas between RELAX-NG, XML Schema, and DTDs. It can also infer a schema from example documents. When converting Trang preserves information such as divisions into files, annotations, and comments. (Trang)
  • Unicorn Formatting Objects is an XSL formatting engine which includes the Unicorn XSLT engine, enabling transformations to go directly from source XML to publishing formats. The engine can convert XSL FO documents to HTML and TeX. A TeX processor can then be used to produce print-ready files from the TeX output. (Unicorn Formatting Objects)
  • VBRELAXNG is a RELAX NG implementation written in Visual Basic, which can validate XML documents against RELAX NG schemas. (VBRELAXNG)
  • Visual XML is an XML editor written in Java with JFC (Swing). It lets you edit a tree view of the XML document. (Visual XML)
  • WFC is a collection of C++ classes for Windows programming. Included are a non-validating XML parser as well as other tools for working with XML documents. The parser has been tested on Unix too. (Windows Foundation Classes)
  • WH2FO reads HTML files produced by Microsoft Word and converts them into an XML document, with two XSLT stylesheets: one for conversion back to HTML and one for conversion to XSL-FO. (WH2FO)
  • Whisper is a general-purpose application framework written in C++, Whisper contains (among many other things) a validating XML parser with support for Unicode. Whisper makes extensive use of C++ features like templates (parametric classes), multiple inheritance, the Standard Template Library and exceptions. The design uses something similar to Design by Contract. (Whisper)
  • X-IT is a tool which can batch process a collection of XML documents, either interactively or non-interactively. It can add PIs or comments, delete parts of a document, replace text, validate and sort. (X-IT)
  • X-Smiles is an XML browser developed in Java. It has a component-based architecture that allows it to run in many different UI environments. In addition, XML vocabularies are rendered by Java components, which can be plugged into the browser. XML documents can also be displayed by using XSLT to transform them into an already supported vocabulary. (X-Smiles)
  • X-Tract is an interpreter for XML Script, an XML transformation language with XML syntax. XML Script can be seen as a non-standard version of XSLT, also using XPath, but with different syntax and based more on a traditional imperative programming model, rather than the functional model of XSLT. It uses the Xerces parser for XML parsing and Pathan for XPath. (X-Tract)
  • XDBM is an open source XML database manager for storing XML documents in and modifying them while in the database. It's designed as a library to be linked into programs. XDBM also has searching functionality. (XDBM)
  • XDOM is an open source XML parser with a DOM level 1 and level 2 (core and traversal) implementation written in Delphi. The implementation implements some convenience extensions and also deviates from the specification in a couple of places. (XDOM)
  • XED is a simple XML editor written in C, Python and Tk. It tries to ensure that the author cannot write a document that is not well-formed and reads the DTD in order to be able to suggest valid elements to be inserted at any point in the document. (XED)
  • XInclude Engine is an XInclude implementation written in Java, with implementations based on SAX, DOM, and JDOM. The engine implements all of XInclude, 2002-09-17 Candidate Recommendation, except referring to fragments of XML documents using XPointer. (XIncluder)
  • XInclude.NET is an XInclude implementation (based on the Candidate Recommendation) written in C# for the .NET platform. (XInclude.NET)
  • XIndice is a native XML database for storing XML documents in and running XPath queries against them. The update language used is XUpdate, and XIndice also implements the XML::DB API. (XIndice)
  • XLE is a tool that uses JDBC to access a relational database and extract data as XML documents. A mapping file is used to map the database model to the desired XML DTD. XLE can exploit foreign key relationships and access several data sources simultaneously. (XML Lightweight Extractors)
  • XML Diff and Merge is a Java program that can be used to reconcile or simply understand the differences between two XML documents. The tool is graphical, and shows the differences using symbols and colours. For each difference the user decides which version to use. (XML Diff and Merge Tool)
  • XML Generator is a tool that can generate valid XML test cases from a DTD, which can be used to test XML applications automatically. The generated XML can be configured somewhat, and the engine can provide both files, a DOM interface and a SAX 2.0 interface. (XML Generator)
  • XML Integrator is an XML data binding tool with support for connecting XML documents with RDBMS tables, rows, and columns. This can be done either using a DTD with Source Annotations (DTDSA) or using an XML language known as XRT. (XML Integrator)
  • XML Master consists of two parts. The first is an editor for generating Java beans from XML DTDs suitable for processing documents conforming to those DTDs. The second part is a collection of beans useful for building GUIs that access XML documents. XMas (as the tool is also known) can generate both visual and non-visual beans. (XML Master)
  • XML Tools Scripting Addition enables AppleScript programs to use expat to parse XML documents into a tree structure of records. It supports XML Namespaces. (XML Tools Scripting Addition)
  • XML TreeDiff is a set of Java beans that work like the UNIX tools diff and patch, but on a DOM 1.0 structure. The package also contains a GUI to display the differences. Difference reports can also be output in XML from the command line. (XML TreeDiff)
  • XML Viewer is a simple Java application that can display both raw XML source and a tree view of any well-formed XML document. XML Viewer is also DTD-aware and can show DTDs as well and show the declaration of any element or attribute. (XML Viewer)
  • XML converters (or "S-converters") are tools for automated processing of XML documents. (General S-converters)
  • XML parsers, parsing toolkits, HyTime engines and DSSSL engines. (Parsers and engines)
  • XML-DBMS is a Java library that can be used to move data from XML to a relational database and also back again. Through the use of a mapping document the structure of the original document is preserved. (XML-DBMS)
  • XML::DT is a Perl package for simplifying down-translation from XML into some other format, for example LaTeX or HTML. XML::DT uses mapping rules that map element type names to Perl handler functions. (XML::DT)
  • XML::Edifact is a set of Perl scripts for converting EDIFACT into an XML representation that mimics the original EDIFACT structure in an XML syntax. A DTD called edicooked.dtd describes the XML structure. (XML::Edifact)
  • XML::Grove uses XML::Parse to build a tree structure from the parsed document that programs can access and change. Similar to DOM, that is, but non-standard. (XML::Grove)
  • XML::LibXSLT is the Gnome XSLT Engine wrapped as a Perl module. The module is considered stable by its author. (XML::LibXSLT)
  • XML::Twig is a module for writing tree-based XML processing applications that only build partial document trees, so as to allow them to work with much larger documents. XML::Twig uses XML::Parser for the actual parsing. (XML::Twig)
  • XML::Writer is a Perl module which makes it easier to generate correct XML output from Perl. It has intelligent support for XML namespaces and will automatically generate prefixes (although this can be controlled, if desired). (XML::Writer)
  • XML::XPath is a Perl implementation of XPath. It can parse XPath expressions and resolve them against a document tree built by the XPath module from SAX events or the XML::Parser. (XML::XPath)
  • XMLIO is a non-validating XML parser with a pull interface, where the application can take over parsing of element contents and elements from the parser. XMLIO can also be used to generate XML documents. (XMLIO)
  • XMill is an XML-specific compression tool that claims to achieve about twice the compression that gzip achieves on XML data at similar speed. It is built on gzip, but uses its knowledge that the input is XML to do XML-specific compression tricks that give better results. (XMill)
  • XOM is a tree-based API for processing XML documents that is designed to be better to use than alternatives such as the DOM, dom4j, and JDOM. It is based on SAX 2.0, but does not work with any SAX 2.0 implementation. XOM allows you to access the element structure, modify documents, and serialize documents back to XML. (XOM)
  • XP is written to be fully-conforming and as fast as possible, with an emphasis is on server-side production use. There is no validation, only well-formedness checking. Even though 0.5 is a beta release it is stable, conformant and fast. A SAX 1.0 driver is included. XP supports several Unicode encodings. (XP)
  • XPA, short for XML Processing for Antlr, is a toolkit for XML processing and transformation based on the Antlr parser generator for Java. It allows XML processing to be described using a declarative grammar syntax interspersed with Java code to perform actions at particular points in the parsing. (XPA)
  • XPath Tester is a GUI tool that can be used to see how XPath expressions evaluate when matched against a specific document. The effect of the expression can be shown as it is typed, and the user can select the context node. The XPath implementation used is the one from Saxon. (XPath Tester)
  • XPath Visualizer can be used to learn XPath and also debug XPath expressions. The visualizer can show an XML document in a tree view and then allows the user to execute an XPath expression against that document, and see which nodes were matched. (XPath Visualizer)
  • XSL Lint is a Perl script that checks XSLT style sheets for mistakes. It is of alpha quality. (XSL Lint)
  • XSL Tester is an XSLT authoring tool that can be used to write XSLT stylesheets and test them on source documents, showing the results either as plain text or as HTML in a browser window. (XSL Tester)
  • XSLP is a free Java XSL processor that implements the final XSLT recommendation. XSLP is based on experience gained by working on Sean Russell's now obsolete docproc processor. (xsl:p)
  • XSLT-process is an Emacs minor mode (that is, it can be used in combination with a major mode such as PSGML or xslide) that adds support for running XSLT processors and debugging the results of XSLT processing. It has quite powerful debugging support, including breakpoints, step-by-step running, and variable viewing. (XSLT-process)
  • XSLTC compiles XSLT stylesheets to C++ code for faster execution. It is based on the TransforMiix XSLT engine and implements 95% percent of its functionality. XSLTC is currently an experimental release. (XSLTC)
  • XSV is an XML validator that validates XML documents according to the XML Schemas Recommendation. Currently, the only interface is a command-line interface. The validator is based on the Python LTXML module, which you can also get by installing XED. XSV supports RDDL. (XML Schema Validator)
  • XSet is an XML search engine oriented towards performance. It keeps its working set in memory (using paging to support large documents) and can be accessed through RMI. The query language is very simple. (XSet)
  • XT is an XSLT engine that implements the final XSLT recommendation, as well as the XPath recommendation. It does not support the full recommendation, but does have some useful extensions. It can be used with any SAX 1.0 parser and also as a servlet. (XT)
  • XTM::Base is a topic map engine that supports XTM 1.0. It can load topic maps from XTM 1.0 documents, and provides a generic API for working with them. There is also a simple text-based interpreter, which can be used to query loaded topic maps, as well as support for XTMPath and LTM. (Perl XTM)
  • Xalan-C++ is a C++ implementation of an XSLT processor, following the final XSLT recommendation. It can pre-parse documents, and precompile stylesheets. The XML parser used is Xerces. (Xalan-C++)
  • Xalan-Java is an XSLT processor written in Java. It implements the entire final XSLT recommendation, and can produce both SAX and DOM output, with support for Java and JavaScript extensions. Xalan-Java uses Xerces-Java for XML parsing. Xalan has a JAXP API. Xalan can also compile XSLT stylesheets to Java bytecode. (Xalan-Java)
  • Xeena is written in Java using Swing, and reads the DTD in order to provide context-sensitive icons for inserting new elements. It can also validate the document. Editing is done in a tree view, but there is a source view as well. (Xeena)
  • Xerces C++ is a validating XML parser written in a portable subset of C++. It supports XML Namespaces, the DOM level 2, SAX 1.0, DOM level 2, SAX 2.0, and XML Schemas. (Xerces C++)
  • Xerces Java is a validating XML parser with support for the DOM level 1 and 2, SAX 1.0 and 2.0, and the XML Schemas final recommendation. Xerces can be invoked through the JAXP API. (Xerces Java)
  • Xerces Perl is the validating Xerces C++ parser wrapped as a Perl module. It supports the DOM level 2, SAX 2.0, XML namespaces, and XML Schema. (Xerces Perl)
  • Xplorer is a simple XML document browser, which can be used to search for XML documents, validate them and view them. Searching is done based on the file name, but it is also possible to search on document content and markup. The viewer can show a tree view, source view as well as a more selective tree view. (Xplorer)
  • Xtract is a document search tool for with a query language loosely based on XQL. Xtract can handle both HTML and XML documents, but is currently at beta level. (Xtract)
  • Zeus is an XML data binding framework that generates Java classes from a DTD, and which can then load data from instances of that DTD to instances of the generated Java classes. It is also able to write data out from the Java objects back to an XML representation. (Zeus)
  • css-mode is a simple Emacs major mode (that is, an extension to the Emacs editor) for editing CSS stylesheets. It does syntax colouring, indentation and auto-completion of property names. (css-mode)
  • debit is an XML editor based on MSIE. It validates as you edit, uses XSLT to transform for preview and allows elements to be reordered (as permitted by the DTD). debit is more suitable for data-oriented XML than for document-oriented XML. (debit)
  • dom4j is a Java toolkit for writing XML processing applications, with its own tree-based model for XML documents, inspired by the XPath data model. It has both event-based and tree-based modes, supports evaluation of XPath expressions against the document tree, and also has an implementation of its own tree model that supports the DOM. There is even alpha support for XML Schema data types. (dom4j)
  • domc is a lightweight DOM level 1 and level 2 core implementation written in pure C. It uses expat to build DOM trees. (domc)
  • dtddoc is a Python tool that can be used to generate HTML and DocBook RefEntry documentation for XML DTDs. It reads the DTD (using xmlproc) and an XML documentation file (using SAX) and generates the documentation from that. The XML DTD for DTD documentation is available separately and is documented using dtddoc. (dtddoc)
  • eXchaNGeR is an XML document manager, which categorizes XML documents in a tree display and allows them to be opened in browser or editor applications. It includes a simple text-based editor and a similar viewer, but can also connect to external services for particular elements. Some services for well-known vocabularies are already included. (eXchaNGeR)
  • eXist is a lightweight XML database that supports fulltext search. It has two backends, one native and one using an RDBMS. The query language implemented is XPath. eXist provides an HTTP interface, an XML-RPC interface, and also implements the XML:DB Java API. eXist uses SAX to import XML documents. (eXist)
  • easyXML is a JavaBean suite for adding XML processing abilities to Java applications. The suite consists of 13 beans: XMLHolder, XMLElement, XMLAttribute, XMLFileGenerator, XML2HTML, HTML2XML, RecursionResolver, NameSpace, XLinkArc, XLinkExtended, XLinkLocator, and XLinkSample. The last three beans provide support for XLink. easyXML can be used with any SAX1 parser. (easyXML)
  • expat is a non-validating parser written in C, and is the parser previously known as XMLTok. It is used in Mozilla 5.0 and in parser modules for several different scripting languages. It is very fast and highly conformant. (XMLTok)
  • ezDTD is a DTD editor that tries to make DTD editing a bit simpler. It stores DTDs in its own format (with metadata), but can import DTDs. It can export DTDs into HTML and save them as either SGML (with minimization info) or XML (without). (ezDTD)
  • fxp is a validating XML parser written in Standard ML, a functional programming language in the ML family. fxp has a programming interface, and comes with some example command-line applications. It has only been tested with the Standard ML of New Jersey compiler under Unix, but might well work elsewhere as well. fxp supports XCatalog and Unicode. (fxp)
  • jd.xslt is an XSLT processor implementing the 2000-12-12 XSLT 1.1 working draft. It claims to have a very high degree of conformance and good performance. The xsl:script element is supported and scripts can be written in many languages. (jd.xslt)
  • jfor converts XSL:FO documents into RTF. jfor attempts to preserve the structure of the input document, and so may lose some formatting. jfor can be used both from the command-line as well as from within Cocoon. (jfor)
  • libxml is a validating XML parser written in C (also known as gnome-xml). It has an event-based (SAX-like) interface and can also build an in-memory DOM-like tree of the parsed document. It can use XML Catalog to resolve entity references. (libxml)
  • libxml-enno is a collection of useful Perl XML modules developed by Enno Derksen and gathered into one package. It contains a DOM 1.0 implementation (built on Clark Cooper's XML::Parser), an XML Query Language (XQL) implementation (note: XQL is not XML-QL), an XML validator that validates documents against DTDs and a number of SAX filters. (libxml-enno)
  • libxslt is an XSLT processor written in portable C, based on the libxml XML parser. It is not yet feature-complete, but work is progressing rapidly. It has both a command-line interface as well as an API. XML Catalog support is provided by libxml. (libxslt)
  • maki is a Python framework for publishing XML documents on the web using a combination of XSLT and Python. maki uses Sab-pyth and 4XSLT (you can choose which you want to use) to provide XSLT processing. (maki)
  • mod_xslt is an Apache module useful for publishing XML documents using XSLT. It uses a configuration file that maps document element names to XSLT stylesheets and when an XML document is requested it automatically applies the XSLT stylesheet to the XML document to produce its output. The XSLT engine used is Sablotron. (mod_xslt)
  • perlSGML is a collection of Perl tools for working with SGML, but they also work with XML. Included are DTD documentation tools, a DTD diff tool and several useful related libraries. (perlSGML)
  • pysp wraps the SP SGML parser as a Python module and makes it easy to develop SGML processing applications in Python. pysp provides a simple event-based API to the SGML parser, the exact minimum of what is required in order to develop applications on top of the parser. (pysp)
  • repat is an RDF parser built on top of the expat XML parser. It uses a callback interface rather like the interface used by expat itself. (repat)
  • sgmlop is a C replacement module for the sgmllib and xmllib parsers that come with the standard Python distribution. The author claims that sgmlop is 6 times faster than the Python originals. (sgmlop)
  • sgrep is a general tool for searching and indexing text that supports XML (and SGML). It also has its own very powerful query language. sgrep supports Unicode. (sgrep)
  • tDOM is a C implementation of the DOM level 1 core using expat and tclexpat for parsing. tDOM also includes C implementations of XPath and . tDOM is written to be accessed from tcl. (tDOM)
  • tmproc is a Python implementation of Topic Maps (ISO 13250), a standard for creating navigational indexes on large sets of documents. tmproc requires the PyXML package and can also be used with xmlarch if architectural processing is wanted. (tmproc)
  • xmlBlaster is a pure Java publish/subscribe MOM server (message-oriented middleware) which exchanges XML-encoded messages between publishers and subscribers. Communication with the server is based on CORBA (using JacORB), RMI and XML-RPC, and subscribers can use XPath expressions to filter the messages they wish to receive. (xmlBlaster)
  • xmlarch is an architectural forms engine written in Python that works with any SAX 1.0 parser and offers a SAX 1.0 interface to the processed documents. It is also possible to receive architectural document events for several architectures in one parse pass. (xmlarch)
  • xmldiff reads two XML documents and compares them using a tree comparison algorithm. xmldiff uses its own tree model, but can build instances of the model from both SAX and DOM2 sources. xmldiff depends on the Python XML-SIG package. xmldiff can output diff results both in a private notation, as well as in the form of an XUpdate document. (xmldiff)
  • xmlizer can produce XML from database contents via JDBC, either using a simple generic mapping or using a rule set. The rule set can be created using a GUI from a DTD or an XML Schema. The product is divided into a server and a client, where the server maintains the configuration and the database connections, and the client connects to it to retrieve XML data. (xmlizer)
  • xmloperator is a tree-based XML editor, which can make use of a DTD or a RELAX-NG schema to provide schema-driven editing. xmloperator is mainly suitable for data-oriented XML rather than document-oriented XML. The editor supports undo, and redo, comparison of documents, as well as conversion using XSLT. It is based on the Xerces-J XML parser and the Xalan-J XSLT engine. (xmloperator)
  • xmlparse is a validating XML parser written in C++ with full Unicode support. The parser has been tested on the OASIS conformance test suite and should be highly conformant (only 3 errors). It uses a SAX-like API and passes text to the application in UTF-8 encoding. (xmlparse)
  • xmlproc is a validating parser written in Python. It implements nearly all of the XML Recommendation, including XML namespaces. (The home page lists the deviations.) xmlproc provides access to DTD information and also offers a DTD parsing module. xmlproc supports SGML Open catalogs and XML Catalogs. xmlproc can report errors in Norwegian and English and can be extended to support other languages as well. (xmlproc)
  • xmltools is a tree-based XML editor and browser written in Python using PyGtk for the graphical interface. It can read the DTD and use the DTD to guide editing of the document. It uses 4DOM, 4XPath and xmlproc. (xmltools)
  • xmlutils is a non-validating XML parser that reads the external subset and external entities (if desired) and produces a Lisp S-expression tree as a result of parsing. The parser supports both Unicode and XML Namespaces. According to the authors it fails only four cases on the OASIS conformance test, and those it fails due to the support for 4-byte Unicode code points. (xmlutils)
  • xslide is a major Emacs mode for editing XSLT style sheets that has both syntax colouring, automatic indention, automatic completion and convenience functions to run XSLT engines. xslide was tested in Emacs 20.3.1. (xslide)
  • xslt-parser is a budding XSLT engine written in Perl. It is of alpha quality and not yet complete nor bug-free, but work is progressing. (XML::XSLT)
  • Ælfred is designed to be small and fast, especially intended for use in Java applets (it uses only two .class files). It has a non-standard interface. Ælfred reads the DTD, but does not validate the document. (Ælfred)
  • Ælfred2 for Pascal is a translation of David Megginson's (and later David Brownell's) Ælfred Java XML parser to Delphi. It supports a SAX-like interface and is validating, and has a high level of conformance against the XML Conformance test suite. (Ælfred2 for Pascal)
  
Object id: 17
Item identifier(s):
[file:/apps/ontopia.net/tomcat/ontopia-5.3.0/topicmaps/xmltools-tm.xtm#TMOR_Description]
(C) Copyright 2001-2011 Ontopia. Some rights reserved.