The Cover PagesThe OASIS Cover Pages: The Online Resource for Markup Language Technologies
Advanced Search
Site Map
CP RSS Channel
Contact Us
Sponsoring CP
About Our Sponsors

Cover Stories
Articles & Papers
Press Releases

XML Query

XML Applications
General Apps
Government Apps
Academic Apps

Technology and Society
Tech Topics
Related Standards
Last modified: October 06, 2004
Microsoft Extensible Application Markup Language (XAML)

XAML (Extensible Application Markup Language) is a code-name for the Microsoft 'Longhorn' Markup Language. This XAML is not to be confused with "Transaction Authority Markup Language (XAML)."


"'Longhorn' application development raises abstraction to the level of a declarative programming model. To facilitate programming for this model a new XML-based declarative programming language (XAML) is being developed. XAML is based on Extensible Markup Language (XML) and enables developers to specify a hierarchy of objects with a set of properties and logic. The primary use of XAML is for 'Longhorn' client applications but you can use it to specify a hierarchy of any common language runtime objects. XAML enables you to create a UI without using code. You can create quite elaborate documents entirely in markup using controls, text, images, shapes and so forth..." [excerpted from Microsoft's XAML Overview]"

Principal URLs

Articles, Papers, News

  • [October 4, 2004] "Xamlon, Inc. Delivers XAML Development Today with Release of Xamlon Pro 1.0. Developers Now Able to Build and Deploy XAML Applications for Microsoft .NET Framework." - "Xamlon, Inc., the only complete XAML resource for developers, announced today the release of its application development package, Xamlon Pro 1.0. Composed of a XAML runtime engine and tool set, Xamlon Pro 1.0 equips developers with the essentials to begin coding in XAML, the XML-based markup language for Microsoft's next-generation operating system scheduled to debut in 2006. With Xamlon Pro 1.0, developers can use XAML to rapidly build and deploy applications for current versions of Windows, gain experience today in the future of Windows user interface development, and write applications that will port easily to future platforms. Introduced by Microsoft in 2003 as the new user interface language for its next operating system, XAML allows developers to separate user interface code from application logic, providing better control over interface layout and drastically reducing development time. This two-tier development model allows developers to change the user interface without rewriting logic and event-handling code. 'The technology behind Microsoft's XAML is revolutionary and is likely to become the new de facto standard. Xamlon, Inc. is committed to the developer community and we want to provide this technology to developers now so they can begin realizing its benefits and be ahead of the curve,' stated Paul Colton, CEO of Xamlon. A key feature of Xamlon Pro 1.0 is a XAML runtime engine that enables developers to easily generate and compile XAML files to create deployable .exe files. Xamlon Pro 1.0 also includes tools and converters that allow developers to use the engine in conjunction with common design programs such as Visual Studio.NET 2003 and Adobe Illustrator. In addition, XamlPad, a XAML notepad, offers quick XAML interface prototyping. Finally, Xamlon offers online XAML education and extensive community forums... Xamlon Inc. is the only complete XAML resource for developers. From XAML literacy to development tools, Xamlon provides everything developers need to start using XAML today. The Xamlon engine enables developers to rapidly build and deploy applications now that will easily port to future versions of Windows. XAML separates interface design from application logic, allowing easier user-interface development. The result is feature-rich, forward-compatible applications in a fraction of the time. Headquartered in San Diego, Xamlon, Inc. was founded in 2003 by Paul Colton, creator of JRun..."

  • [April 29, 2004] "Longhorn's Real Job: Trying to Gore Linux." By Steven J. Vaughan-Nichols. In eWEEK (April 29, 2004). ['Microsoft's No. 1 job for Longhorn is to make money, but killing off the Linux desktop isn't far behind, Linux and Open-Source Center Editor Steven Vaughan-Nichols writes.'] "Now, after having their hands gently slapped by the Department of Justice, the boys from Redmond have another plan: Make it so that users of their next desktop system won't be able to use non-Microsoft-blessed servers or programs at all. I'm not the only one who sees this coming. The GNOME Foundation and Mozilla Foundation teams also see it coming, and they're trying to come up with a plan of defense. They're convinced that Avalon, Longhorn's presentation subsystem, and XAML, Avalon's Extensible Application Markup Language, will lock in users to Microsoft's proprietary programs or only to programs written with Microsoft-proprietary tools. Me, I think that's a big deal, but I think WinFS, Longhorn's file system, is at least as big a problem. You see, Microsoft is busy patenting everything it can lay its hands on with all three. In fact, Microsoft is now building up its patent arsenal, applying for a rather amazing 10 patents a day. The idea isn't to ensure that Microsoft makes a fair profit from its patents; it's to make sure that no one else can write fully compatible software. The irony of this is twofold: It's exactly the opposite of what the patent system was supposed to do, and XML was meant to open internetwork and interapplication communications, not provide a way to lock them up. The open-source leaders are considering ways around these problems, such as promoting the use of open standards-based technologies like GNOME's open-source GUI toolkit, GTK+ and Mozilla's User Interface Language, XUL. Or, taking a leaf from the Samba crew, just try to reverse-engineer and clone Avalon and XAML. Either approach could work, but work needs to start sooner rather than later, no matter which direction developers end up going in... Miguel de Icaza, one of the most respected open-source programmers and father of the Mono project, which attempts to bring .NET to Linux, says it best. He writes in his blog, 'What makes Longhorn dangerous for the viability of Linux on the desktop is that the combination of Microsoft deployment power, XAML, Avalon and .NET is killer'..."

  • [April 29, 2004] "A Standards-based Look at XAML's Features." By Nigel McFarlane. From (April 20, 2004). ['Microsoft's Longhorn will introduce XAML, an application development framework for Web and Windows apps. But just how different is XAML from the already-available public standards set by the W3C?'] "Microsoft's XAML markup language floats on top of the .NET platform. It is compiled into .NET classes, usually C#, which reduces it to a set of objects. Along with a host of other XML dialects it is an example of a new type of specification for GUIs. This article takes a look at XAML's tags to see what (if anything) is new in them. There are many such GUI specifications now, a few being Mozilla's XUL, Oracle's UIX, Macromedia's Flex and the XML files created by the Gnome Glade tool. Although not W3C standards, some of these new GUI specifications are already on the W3C standards track. An example is the box model used within Mozilla's XUL, which is headed toward inclusion in future CSS drafts. The original and most popular source of XML definitions is, however, still the World Wide Web Consortium. The W3C is responsible for formalizing XML and many XML applications such as XHTML and SVG. Given that these standards are mostly complete, do we really need all these new XML GUI dialects? Microsoft's XAML is a new spin on XML-based GUI description languages, borrowing very little syntax from established standards. Let's see if it's a radical improvement in some way, or if it's merely familiar old friends dressed up in new clothes... Why XAML doesn't use CSS2 is a mystery. Perhaps that'll change by the time the final Longhorn release is upon us. At least then we'd have all the alternatives for these CSS2 properties, not just a sprinkling of them... In addition to hypertext and GUI widgets, XAML supports two-dimensional graphics. The equivalent W3C standard is SVG... In line with Microsoft's tendency to put the most popular features of a given technology to the front and center, this list of tags extracts from the SVG standard the most obvious graphical elements you might want in a given diagram. Of all the W3C standards, SVG is probably the one most suitable for generation via point-and-click design tools, rather than hand-coded XML tags. It's encouraging to see that XAML supports simple hand coding, using simple tags, as some of us never want to let go of that. At the same time, there's no way the current features are enough to support a point-and-click two-dimensional design tool, at least not one of any consequence... In the bigger picture, Microsoft's Avalon display system integrates the XAML tags together far more tightly than any other XML display system so far. This is most obvious in the SVG-like two-dimensional effects that XAML can apply to XUL-like widgets and to XHTML-like content. Although Mozilla allows deep integration between SVG, CSS, XHTML, and XUL, it doesn't yet go as far as XAML in applying the processing tricks of one standard to all the tags of all the others. Then again, XAML's support for CSS, by comparison, is nonexistent. The unifying approach that CSS brings to various W3C standards is sorely missed in XAML by this writer. If XAML presented a substitute styling system that was as integrated as CSS, then XAML would be another matter — at least then we could have a proper technology shoot-out. Examined superficially, XAML tags have many of the features of traditional Web standards like HTML, as well as those of newer Web approaches like Mozilla's XUL. Alas, it lacks proper CSS stylesheet support. Examined more deeply, however, XAML tags reuse, reinvent, and renew many standard idioms from the software development world in a highly integrated way..."

  • [April 29, 2004] "Open-Source Backers Ready Longhorn Defense." By Mary Jo Foley. In Microsoft Watch [eWEEK] (April 21, 2004). "The open-source development community is looking to head off Microsoft Longhorn before it escapes the Redmond corral. Some key members of the community recently met to discuss ways the open-source movement can prepare for Longhorn, the next major version of Windows that is expected to debut on the desktop in 2006. According to the minutes posted to the Web from an April 21, 2004 meeting involving members of the Gnome Foundation and the Mozilla Foundation teams, Longhorn's Avalon and XAML technologies appear to be the most potentially worrisome for the open- source community. Avalon is the code name for the presentation subsystem that Microsoft is building to be part of Longhorn. XAML is the Extensible Application Markup Language that is tightly integrated with Avalon and will be the primary vehicle for writing Avalon application. Gnome co-founder Nat Friedman suggested that open-source vendors look into the possibilities of cloning XAML, as well as possibly building an Avalon competitor consisting of open-source components. Candidates for this collection include the GIMP-based GTK+, a library for creating graphical user interfaces for the X Window System, and the XML User Interface Language (XUL) developed by Mozilla..." See also "XML Markup Languages for User Interface Definition."

  • [January 27, 2004] "Inside XAML." By Ian Griffiths. From O'Reilly (January 05, 2004). "One of Longhorn's most interesting technologies for developers is its new XML-based markup language, codenamed XAML (short for eXtensible Application Markup Language, and pronounced 'Zammel'). User interfaces in Longhorn applications are typically built using XAML. In this article, we look at how XAML relates to the underlying support provided by WinFX. XAML user interfaces are built in much the same way as HTML web user interfaces -- you simply create a document with tags for each of the user interface elements you require... You might be wondering why Microsoft decided to invent a brand-new markup language for building user interfaces, rather than using HTML or SVG. One of the reasons is functionality -- Avalon provides many sophisticated user interface features that are not available in HTML, such as scaling and rotation of both text and graphics, and animation. Also, HTML has been developed primarily for use on the Web, whereas XAML's principal target is applications that run directly on Windows (i.e., 'rich clients' or 'smart clients'). But this still leaves the question of why Microsoft didn't use SVG (Scalable Vector Graphics -- a graphically rich, XML-based markup language.) After all, SVG addresses many of HTML's shortcomings as a rich-client markup language. However, the most powerful reason for devising a new markup language is the very close relationship between elements in a XAML file, and objects at runtime. Unlike any previous markup languages, XAML is designed to integrate directly with WinFX... XAML is a simple but powerful way of building trees of .NET objects. Because it is based on XML, it is straightforward to create XAML-based markup. This not only makes it easy to build user interfaces by hand, it also makes it relatively straightforward for tools to generate XAML -- in the future, design tools will emerge that are able to export documents and drawings in XAML format. It is also easy to use technologies such as XSLT to transform XML data sources into XAML documents. XAML enables a clean separation of user interface from code through the use of code-behind files, while its close integration with WinFX makes it very easy for code to manipulate the user interface elements defined in the markup..."

  • [Decmber 18, 2003] "Special Holiday Episode - XAML Beyond the Basics." From MSDN TV. Chris Anderson and Don Box show how to use the new XAML programming model for more than just building UI applications with Avalon. Requires Microsoft Windows Media Player.

  • [December 16, 2003] "Longhorn for Developers: Controls and XAML." By Brent Rector. In Microsoft MSDN Library (December 16, 2003). From Introducing "Longhorn" for Developers. "Longhorn platform applications typically consist of an Application object and a set of user interface pages that you write in a declarative markup language called XAML. The Application object is a singleton and persists throughout the lifetime of the application. It allows your application logic to handle top-level events and share code and state among pages. The Application object also determines whether the application is a single window application or a navigation application. You typically write each user interface page using a dialect of XML named Extensible Application Markup Language (XAML). Each page consists of XAML elements, text nodes, and other components organized in a hierarchical tree. The hierarchical relationship of these components determines how the page renders and behaves. You can also consider a XAML page to be a description of an object model. When the runtime creates the page, it instantiates each of the elements and nodes described in the XAML document and creates an equivalent object model in memory. You can manipulate this object model programmatically -- for example, you can add and remove elements and nodes to cause the page to render and behave differently. Fundamentally, a XAML page describes the classes that the runtime should create, the property values and event handlers for the instances of the classes, and an object model hierarchy -- that is, which instance is the parent of another instance. All XAML documents are well-formed XML documents that use a defined set of element names. Therefore, all rules regarding the formation of well-formed XML documents apply equally to XAML documents... Each XAML page contains one or more elements that control the layout and behavior of the page. You arrange these elements hierarchically in a tree. Every element has only one parent. Elements can generally have any number of child elements. However, some element types -- for example, Scrollbar -- have no children; and other element types -- for example, Border -- can have a single child element. Each element name corresponds to the name of a managed class. Adding an element to a XAML document causes the runtime to create an instance of the corresponding class... A XAML page typically begins with a panel element. The panel is a container for a page's content and controls the positioning and rendering of that content. In fact, when you display anything using XAML, a panel is always involved, although sometimes it is implicit rather than one you describe explicitly. A panel can contain other panels, allowing you to partition the display surface into regions, each controlled by its panel... XAML has all the controls you've come to expect from Windows -- buttons, check boxes, radio buttons, list boxes, combo boxes, menus, scroll bars, sliders, and so on..."

  • [November 04, 2003] "'Longhorn' Markup Language (code-named 'XAML') Overview." Draft (snapshot). "This topic summarizes the new 'Longhorn' markup language (code-named 'XAML'), describes what advantages it provides over other programming languages, and demonstrates how to write applications with it. 'XAML' is based on Extensible Markup Language (XML) and enables developers to specify a hierarchy of objects with a set of properties and logic. The primary use of 'XAML' is for 'Longhorn' client applications but you can use it to specify a hierarchy of any common language runtime objects... 'Longhorn' application development raises abstraction to the level of a declarative programming model. To facilitate programming for this model a new XML-based declarative programming language, 'XAML', is being developed... 'XAML' is the primary way to create a UI in the 'Longhorn' programming model because it provides a way to separate UI definition from logic and enables you to integrate code within or behind markup. The ability to mix code with markup is important because XML does not support flow control well. In 'Longhorn', applications can be written entirely in 'XAML' and deployed 'loose' like HTML but if you need imperative code to react to user interaction you must mix markup with code and compile the application... You can create quite elaborate documents entirely in markup using controls, text, images, shapes and so forth..."

  • [October 31, 2003] "A Brief History of XAML." By Chris Anderson (Microsoft). October 31, 2003. "An early debate on the Avalon team was about what our markup should look like. We knew that we wanted a declarative UI model - it is actually something we have had for a long time. The Avalon team was formed with members from all over the company - User, IE, etc. And each team had a different history with markup. Obviously the IE folks had used HTML and VML in the past, while the User folks had used RC files. To add to the great debate there was also the new success of ASP.NET and their form of markup. After great debate, we decided that the programatic object model would be based on .NET conventions. We also felt that the markup should have the same programming model as code. Neither HTML nor RC files had this 'markup == object model' tenet, and it made programming difficult. ASP.NET had (basically) this model, and people seemed to really like that. Finally we decided that the markup should be a new format that was, in fact, a persistence format for .NET objects... one of our current debates - is XAML a programming language or a resource format? With XAML you can define new types, define interactivity with 'def:Code', and specifiy member variables of the type using 'ID'. XAML also defines the UI appearance of something, and is used for localization scenarios. XAML lacks any imperitive constructs (branching, etc.). XAML is more of a 'programming model' rather than a language, so we have left it at that - 'XAML is a declarative programming model'. In the PDC bits their are two modes of XAML compilation - binary (BAML) and code (CAML). We are still working on analyising the two options - CAML works just like ASP.NET, it converts XAML into code (VB.NET, C#, C++, any other CodeDOM language)... BAML uses a binary format and also creates a small section of code for the parts of XAML that can't be represented in binary (like the outer class definition). CAML is the default in PDC bits, and you can use Optimization='Download' in the project file for getting BAML..."

  • [October 30, 2003] "Gooey Standards." By Chris Ckaminski. The Web Standards Project Buzz. " Microsoft's XAML is the newest entry into the XML-GUI arena, and the one that is most responsible for the recent buzz. It is in fact an integral part of the application development model for the next version of Windows (Longhorn). XAML is an XML syntax for using Microsoft's new vector-based drawing library, Avalon. What appears reasonably clear is that XAML eschews W3C recommendations like SMIL, SVG and the DOM in favor of similar -- but incompatible -- techniques unique to XAML. How successful XAML will be outside Windows applications is hard to say. Adobe apparently has a plugin for AfterEffects that will produce XAML. Will other vendors follow suit? Steve Maine thinks so. He feels XAML will beat out other technologies because end users don't care about platform independence..."

  • [October 27, 2003] "Code Name Avalon: Create Real Apps Using New Code and Markup Model." By Charles Petzold. In Microsoft MSDN Magazine Volume 19 Number 1 (January 2004). "The new presentation subsystem in the next version of Windows, code-named 'Longhorn,' offers powerful new capabilities to developers. This new subsystem, code-named 'Avalon,' allows developers to take advantage of its capabilities through a language -- Extensible Application Markup Language (code-named 'XAML'), as well as through modern object-oriented programming languages such as C#. Because most applications written to Avalon will probably be a mix of XAML and programming code, this article discusses XAML tags used to control page layout along with the procedural code written to respond to events. Avalon consists mostly of a new collection of classes added to the .NET Framework... In addition, Avalon also defines a new markup language you can use in Longhorn that's code-named 'XAML.' You use XAML much like HTML to define a layout of text, images, and controls. Being based on XML, XAML has stricter and much less ambiguous syntax than HTML. It is expected that most XAML will be machine-generated by visual design programs, but it may be a good learning experience to hand-write your own XAML (initially). Most applications written to Avalon will probably contain both program code and XAML. You'll use the XAML for defining the initial visual interface of your application, and write code for doing everything else. You can embed the program code directly in XAML or keep it in a separate file. Everything you can do in XAML you can also do in program code, so it's possible to write a program without using any XAML at all. The reverse is not true, however; there are many tasks that can only be done in program code, so only the simplest applications will consist entirely of XAML. Here's a little snippet of some XAML: <Button Background='LightSeaGreen' FontSize='24pt'>Calculate</Button>... XAML has very intimate ties with the Avalon class library: every element type you can use in XAML is actually a class and, specifically, a descendent of the UIElement or ContentElement classes declared in the MSAvalon.Windows namespace. Among the descendents of UIElement is Control, from which are descended all the common user-interface controls such as buttons, scroll bars, list boxes, edit fields, and so forth. Classes derived from ContentElement include Bold and Italic. Of course, the modern programmer wants to know: can I use my own classes as XAML elements? And the answer is: of course you can. XAML is called the Extensible Application Markup Language for a reason. Any class that has a public parameterless constructor and settable properties can be used in XAML... The hierarchical nature of XAML is one reason why a markup language makes more sense than programming code for defining a visual interface. The markup can mimic the hierarchy with nesting and indentation. In fact, when Windows 1.0 was first introduced in 1985, programmers used a text resource script to define the hierarchical structure of their menus and dialog boxes. At the time, the hierarchy only went one level deep, but it was a start. An XAML file is just the resource script... Avalon and XAML represent a departure from Windows-based application programming of the past. In many ways, designing your application's UI will be easier than it used to be and deploying it will be a snap. With a lightweight XAML markup for UI definition, Longhorn-based applications are the obvious next step in the convergence of the Web and desktop programming models, combining the best of both approaches..." See also "XML Markup Languages for User Interface Definition."

  • [October 27, 2003] "A First Look at Writing and Deploying Apps in the Next Generation of Windows." By Dino Esposito. In Microsoft MSDN Magazine Volume 19 Number 1 (January 2004). "The Longhorn version of Windows includes a new storage system, natural search technology, and an increased emphasis on security and trustworthy computing. Here the author provides an overview of Longhorn, focusing on the build-once, deploy n-times application model. In addition, he discusses the new language, code-named 'XAML,' that's used to create UI elements, then presents some working samples... XAML is the language used to declaratively render the user interface of the pages that make up the application. In addition to using XAML, you can also write applications for Longhorn entirely with procedural code. In general, successful Longhorn-based applications have two ingredients -- XAML pages and managed procedural code. How you combine them is up to you, but any combination of the two is acceptable. By using a combination of XAML and C# (or Visual Basic .NET) code, you can build various types of output files including traditional Windows desktop executables, DLL libraries, and console applications. In addition, if your application is simple enough, it can be rendered using freestanding XAML markup, thus producing another type of application to add to the list. Standalone XAML files are runnable within the Longhorn shell and the browser as long as they don't reference some codebehind class... the suite of XAML markup tags is more abstract and broader than the set of Win32 common controls or Windows Forms controls. To get an immediate grasp of what XAML represents and how you should look at it, think of ASP.NET pages. Or, more specifically, think of a particular ASP.NET page in which you only find server-side controls (runat="server") and no literal text. Each and every XAML tag corresponds to a .NET Framework class and comes with a collection of methods, properties, and events. You can set properties and wire events declaratively in the XAML script, as well as use procedural code packed into a codebehind class. The control behind each tag is instantiated at run time and given an area of the screen on which to render its output. At the highest level of abstraction, the model looks a lot like ASP.NET, only abstracted to work for a generic, richer Windows platform. Every element in XAML uses an underlying class, but there are many classes that do not have corresponding XAML elements. These are often abstract classes that are mostly used for inheritance. Anything you can create in XAML can be created in procedural code..."

  • [October 27, 2003] "Some XAML Comments." By Neil Deakin. October 27, 2003. "I took a quick look at XAML to see how it compares to XUL, or anything..."

Hosted By
OASIS - Organization for the Advancement of Structured Information Standards

Sponsored By

IBM Corporation
ISIS Papyrus
Microsoft Corporation
Oracle Corporation


XML Daily Newslink
Receive daily news updates from Managing Editor, Robin Cover.

 Newsletter Subscription
 Newsletter Archives
Globe Image

Document URI:  —  Legal stuff
Robin Cover, Editor: