Is it possible to program using the WinRT API without using XAML?

WPF has nothing to do with HTML!

You can use WPF without XAML (XAML actually always translates to C #).

It's as simple as Windows Forms:

Ex: Let's suppose I want to make a page (not to be confused with webpage) for a Windows 8 app with a label and a button, with binding :

using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Data;

namespace App1
{
public class TestPage : Windows.UI.Xaml.Controls.Page
{

    public TestPage()
    {
        var stackPanel = new StackPanel();
        var label = new TextBlock { Text = "Hello World" };
        var button = new Button();
        var buttonCaption = new TextBlock();

        buttonCaption.SetBinding(TextBlock.TextProperty, new Binding { Path = new Windows.UI.Xaml.PropertyPath("Text"), Source = label });
        button.Content = buttonCaption;

        stackPanel.Children.Add(label);
        stackPanel.Children.Add(button);

        var layoutRoot = new Grid
        {
            HorizontalAlignment = Windows.UI.Xaml.HorizontalAlignment.Center,
            VerticalAlignment = Windows.UI.Xaml.VerticalAlignment.Center,
        };

        layoutRoot.Children.Add(stackPanel);
        Content = layoutRoot;
        }

        }

}

Responding to the questions in the comment:

This is WinRT (that is, Silverlight for Windows Store Apps).

I have no references other than the XAML documentation. Everything XAML does, there is a corresponding class. If you have Grid , StackPanel , Button , etc. in XAML, it will fatally have them in the WPF namespace (whatever version it is). This includes features such as binding and static resources .

There is no "place with authority that affirms ...", but this is intrinsic. C # does not compile or run XAML, it at most interprets and mounts the screen with the objects contained in namespace Windows.UI.Xaml . There is nothing that exists in XAML that does not exist in this namespace (after all, XAML does not exist at all).

You can accomplish any task in this way, although this is very bad. XAML makes writing easy and makes some shortcuts that you have to use to do it manually. An example of this is putting text inside a button. In XAML, it's simple. In code you must explicitly specify that the contents of the button is TextBlock (something like Label ).

You're confusing things a little. XAML is just the name of markup (it never actually runs, is always converted or interpreted). The fact that is called XAML is because MS intended WPF to be used with a markup language aid and there is absolutely no reason not to use it , at least in part. WPF binding is powerful enough to avoid creating components on hand. But of course, .net is a framework that gives you the freedom to do whatever you want.

According to the Marcos Zolnowski :

For WinRT it is possible to use HTML instead of XAML. If you only create objects via javascript, I believe this answers your question (without XAML and only via code). But I believe this is not the answer you are looking for, if it is, I will transfer it to the answers section.

I would add that you can dynamically create elements a>:

        // Popula contatos do XElement com informações de Contacts.  
        XElement contacts =
            new XElement("Contacts",
                new XElement("Contact1",
                    new XElement("Name", "Patrick Hines"),
                    new XElement("Phone", "206-555-0144"),
                    new XElement("Address",
                        new XElement("Street1", "123 Main St"),
                        new XElement("City", "Mercer Island"),
                        new XElement("State", "WA"),
                        new XElement("Postal", "68042")
                    )
                ),
                new XElement("Contact2",
                    new XElement("Name", "Yoshi Latime"),
                    new XElement("Phone", "503-555-6874"),
                    new XElement("Address",
                        new XElement("Street1", "City Center Plaza 516 Main St."),
                        new XElement("City", "Elgin"),
                        new XElement("State", "OR"),
                        new XElement("Postal", "97827")
                    )
                )
            );

        // Cria o primeiro controle TextBlock.
        // Note que o elemento precisa declarar dois namespaces XAML.
        XElement textBlock1 = XElement.Parse(
                @"<TextBlock 
    xmlns='http://schemas.microsoft.com/client/2007' 
    xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml' 
    TextWrapping= 'Wrap'
    Width = '400'
    Canvas.Top = '10'
    Text=''/>");

        // Pega o primeiro elemento filho da árvore de contatos do xml.
        XElement contact1 = contacts.Element("Contact1");

        // Ajusta o valor do último atributo "Text"
        // com o conteúdo dos contatos da árvore do xml.
        textBlock1.LastAttribute.SetValue(contact1.ToString());


        // Pega o segundo elemento filho da árvore de contatos do xml.
        XElement contact2 = contacts.Element("Contact2");

        // Cria o segundo controle TextBlock.
        // Note que o elemento precisa declarar dois namespaces XAML.
        XNamespace xmlns = "http://schemas.microsoft.com/client/2007";
        XElement textBlock2 = new XElement(xmlns + "TextBlock",
            new XAttribute(XNamespace.Xmlns + "x", "http://schemas.microsoft.com/winfx/2006/xaml"),
            new XAttribute("Canvas.Top", 250),
            new XAttribute("Width", "600"),
            new XAttribute("Text", contact2.ToString())
            );


        // Adiciona o controle TextBlock à página
        LayoutRoot.Children.Add(XamlReader.Load(textBlock1.ToString()) as UIElement);
        // Adiciona o controle TextBlock à página
        LayoutRoot.Children.Add(XamlReader.Load(textBlock2.ToString()) as UIElement);