Aurelia 1 Docs
Website
  • Introduction
  • Introduction
    • Quick Start
    • Aurelia for new developers
    • Contact manager tutorial
  • Components
    • Component basics
    • Component lifecycles
    • Styling components
    • Component options
    • Bindable properties
    • Slotted content
    • Template compilation using processContent
  • Templates
    • Template syntax
      • Attribute binding
      • Event binding
      • Text interpolation
      • Element content
      • Function references
      • Element references
      • Contextual properties
      • Expression syntax
      • Binding
    • Custom attributes
    • Value converters (pipes)
    • Binding behaviors
    • Form inputs
    • CSS classes and styling
    • List rendering (repeaters)
    • Conditional rendering
    • HTML & SVG attributes
    • The as-element (element aliasing)
    • View Resource pipeline
    • View and Compilation Spies
  • Getting to know Aurelia
    • App configuration and startup
    • Routing
      • Getting started
      • Router configuration
      • Configuring routes
      • Viewports
      • Layouts
      • Redirecting routes
      • View Swapping and Animation
      • Internationalizing Titles
      • Fallback Routes
      • Navigating
      • Lifecycle hooks
      • Router pipelines (hooks)
      • Reusing an Existing View Model
      • Router events
    • Enhance
    • Dynamic composition
    • Observation
    • Dependency injection (DI)
      • Overview
      • Injection
      • Resolvers
    • Task queue
    • Event aggregator
    • Server side rendering
      • Caveats
      • How it works
      • Isomorphic code
      • Memory management
      • Different entry points
      • 404 pages
    • CLI
      • Machine setup
      • Creating a new project
      • Running your app
      • Environments
      • Building your app
      • Generators
      • Configuration with aurelia.json
      • Webpack vs built-in bundler
      • Gulp tasks
      • Webpack
      • Built-in bundler
      • Updating & migrating
      • Recipes & known issues
      • Getting help
  • Developer guides
    • Animation
    • Testing
      • Unit Testing
        • Testing Custom Elements
        • Testing Custom Attributes
        • Testing Routing and Navigation
        • Advanced Testing
        • Helpful Properties, Functions, and Advanced Querying
        • Dependency Injection Testing
        • Testing Custom Value Converters and Binding Behaviors
        • Internationalization (i18n) Testing
      • End-to-end testing
        • Getting started with Playwright
        • Writing E2E tests
        • Advanced Techniques
    • Logging
    • Building plugins
      • Plugin Development
      • Building and Publishing
      • Advanced Plugin Techniques
    • UI Virtualization
    • Integrations
    • Cheat sheet
  • Aurelia packages
    • Validation
    • i18n Internationalization
    • Dialogs
    • Fetch client
    • HTTP client
    • Store
      • Configuring your app
      • What is the State?
      • Reasons for state management
      • Subscribing to the stream of states
      • Subscribing with the connectTo decorator
      • What are actions?
      • Async actions
      • Dispatching actions
      • Resetting the store to a specific state
      • Two-way binding and state management
      • Recording a navigable history of the stream of states
      • Making our app history-aware
      • Navigating through history
      • Handling side-effects with middleware
      • Accessing the original (unmodified) state in a middleware
      • Defining settings for middlewares
      • Error Propagation with Middlewares
      • Default middlewares
      • Tracking overall performance
      • Defining custom devToolsOptions
      • Defining custom loglevels
      • Debugging with the Redux devtools extension
      • Comparison to other state management libraries
Powered by GitBook
On this page
  • What is Aurelia 1?
  • Why choose Aurelia 1?
  • Embracing a Boutique Ecosystem
  • The Power of Conventional DOM Manipulation: why Aurelia 1 doesn't have a Virtual DOM
  • Navigating The Aurelia 1 Docs
  • How to Be Part of the Community
  • Where To Begin

Was this helpful?

Export as PDF

Introduction

Get acquainted with Aurelia 1, the documentation, and how to get started.

NextQuick Start

Last updated 9 months ago

Was this helpful?

Important Note for New Projects

We strongly recommend using Aurelia 2 for all new projects. Aurelia 2 represents the latest evolution of the framework, offering improved performance, enhanced features, and ongoing support.

As documented here, Aurelia 1 is now primarily maintained for legacy projects. While it remains a robust solution, new development should focus on Aurelia 2 to leverage the most current capabilities and future updates.

If you're working on an existing Aurelia 1 project, this documentation will continue to serve as a valuable resource.

What is Aurelia 1?

Welcome to Aurelia 1, the powerful, open-source JavaScript framework for crafting extraordinary web applications. At its core, Aurelia 1 is more than just a framework; it believes in the unbridled power of open web standards. With Aurelia 1, your development experience is streamlined, intuitive, and flexible.

Aurelia 1 isn't just feature-rich; it's a testament to high performance and extensive extensibility, offering a component-oriented design that's fully testable. It's built for developers who know the value of simplicity and the importance of conventions that don't obstruct but enhance creativity.

To start, jump to our Quick Start Guide or read on for an overview.

Why choose Aurelia 1?

Aurelia 1 emerges as a beacon of innovation and power in front-end development in a sea of frameworks. Here's why Aurelia 1 might be the perfect choice for your next project:

  • All-in-One Ecosystem: Aurelia 1 is your Swiss Army knife, offering everything from dependency injection to routing, eliminating the need to juggle multiple libraries. Its ecosystem extends to plugins for internationalization, validation, and more, supported by tools like a CLI for seamless development.

  • Unparalleled Performance: Speed and efficiency are in Aurelia 1's DNA. It consistently outperforms competitors in benchmarks thanks to its sophisticated batched rendering and efficient memory usage.

  • Data-Binding Done Right: Aurelia 1 harmonizes the safety of uni-directional data flow with data-binding productivity, ensuring both performance and ease of development.

  • Stability in a Dynamic World: Since our 1.0 release in 2016, Aurelia 1 has maintained API stability, innovating without breaking changes, a testament to our commitment to developer trust.

  • Adherence to High Standards: Aurelia 1 is a paragon of standards compliance, focusing on modern JavaScript without unnecessary abstractions.

  • Empowering Developers: Aurelia 1's philosophy is simple: empower developers with plain JavaScript and get out of the way. This results in cleaner, more maintainable code.

  • Ease of Learning and Use: Aurelia 1's design is intuitive and consistent, minimizing the learning curve and maximizing productivity with solid, simple conventions.

  • Seamless Integration: Aurelia 1 plays well with others. Its adherence to web standards makes it a breeze to integrate with any third-party library or framework.

  • A Vibrant Open-Source Community: Embrace the open-source ethos with Aurelia 1, licensed under MIT, without restrictive clauses. Join a community that thrives on collaboration and innovation.

  • A Welcoming and Supportive Community: Our active core team and Gitter chat embody a culture of welcome and support, where every developer is a valued member of the Aurelia family.

Embracing a Boutique Ecosystem

While it's true that Aurelia 1's ecosystem and community might seem modest compared to some of its more populous counterparts, this perceived underdog status is, in fact, one of its greatest strengths. Aurelia 1 represents a boutique choice in web frameworks, prioritizing quality over quantity and fostering a tight-knit, highly engaged community. This approach translates to a more focused, consistent, and dedicated development experience, both in terms of the framework itself and the support you receive from the community.

The Advantages of a Niche Community

  • Direct Impact: In a smaller community, each member's voice and contribution have a more significant impact. Developers have direct access to the core team, fostering a collaborative environment where feedback and contributions influence the framework's evolution.

  • Quality Over Quantity: Aurelia 1 focuses on delivering a high-quality, refined development experience. Each plugin, library, and tool in the ecosystem has been carefully crafted and thoroughly vetted to meet high standards.

  • Nurturing Innovation: A smaller ecosystem doesn't mean limited capabilities. On the contrary, it often leads to innovative solutions and creative problem-solving, as developers are encouraged to think outside the box.

  • Stronger Connections: A smaller community fosters closer relationships, leading to more meaningful interactions, collaborations, and a sense of belonging. This environment is conducive to a supportive and helpful atmosphere where developers at all levels can thrive.

Why Size Isn't Everything

The size of a community or ecosystem should not be the sole criterion for its effectiveness. In many cases, the quality of interactions, the dedication of its members, and the framework's alignment with your project's needs are far more critical factors. Aurelia 1's commitment to standards, modern best practices, and empowering approach offers a unique and rewarding development experience that stands on its own merits.

The Power of Conventional DOM Manipulation: why Aurelia 1 doesn't have a Virtual DOM

In a landscape where Virtual DOM is often touted as a necessity, Aurelia 1 confidently takes a different path. Aurelia 1's choice not to use a Virtual DOM is a deliberate and strategic decision grounded in a philosophy that prioritizes efficiency, simplicity, and alignment with web standards.

Understanding the Conventional DOM Approach

  • Directness and Efficiency: Aurelia 1 interacts directly and efficiently with the DOM. By avoiding the overhead of a Virtual DOM, Aurelia 1 ensures faster rendering and updates, leading to a smoother user experience.

  • Simplicity and Predictability: Without the abstraction layer of a Virtual DOM, Aurelia 1 offers a more straightforward and predictable development experience. Developers work closer to the web platform, leveraging native browser capabilities for DOM manipulation.

  • Optimal Performance: Aurelia 1's approach to DOM updates is highly optimized. It intelligently manages DOM changes, ensuring minimal performance overhead. This results in applications that are not only fast but also more resource-efficient.

The Benefits of Conventional DOM in Aurelia 1

  • Aligned with Web Standards: Aurelia 1's commitment to standards means that it leverages the native capabilities of modern browsers, ensuring compatibility and future-proofing your applications.

  • Less Complexity, More Control: By avoiding a Virtual DOM, Aurelia 1 reduces the complexity of your application's architecture. This direct approach gives developers more control and understanding of how their application interacts with the browser.

  • Tailored for Modern Web Development: Aurelia 1 is designed to meet the needs of modern web applications. Its efficient, standards-based approach is perfectly suited for today's dynamic, interactive web experiences.

The decision not to use a Virtual DOM reflects Aurelia 1's overarching philosophy: to provide a powerful, efficient, and straightforward framework that stays true to the web's nature. This approach encourages developers to build both performant and maintainable applications, leveraging the web platform's full potential.

Navigating The Aurelia 1 Docs

Your journey with Aurelia 1 begins here in our meticulously crafted documentation. Start with the Quick Start Guide to grasp the basics of building an Aurelia 1 application. The "Getting Started" section is your next stop, followed by "App Basics" for a deep dive into regular Aurelia 1 usage.

As your comfort with Aurelia 1 grows, explore "Advanced Scenarios" for insights into performance optimization and large-scale project management. While you may find less need for raw API documentation due to Aurelia 1's convention-based approach, our "API" section is comprehensive. Don't miss the "Examples" section, where practical code samples for common scenarios are found. Our "Resources" section is a treasure trove of FAQs, framework comparisons, and much more.

Did you find something amiss in our documentation? Every page includes an "Edit on GitHub" link, making it easy to contribute corrections or improvements.

How to Be Part of the Community

Where To Begin

You're in the right place. If you are starting with Aurelia 1, we highly recommend reading through our Quick Start Guide. It will show you how to create a project and build your first components using Aurelia 1's powerful templating system.

As you become more familiar with Aurelia 1, perhaps you will come up with something you would like to share with the community. The Aurelia team welcomes any contributions you feel would benefit others in the community. Check out the "Community Contribution" section if that is the case. We welcome any feedback or suggestions to help improve Aurelia 1 and enrich the community. Check out the "" for details about the contributing process and how to contact us.

😎
Contributor Guide