We're thrilled that you've decided to get to know Symphony a little better. This guide will walk you through everything you need to know before you begin working on your first project. You'll get an overview of Symphony's unique approach to content management, a breakdown of how the system is structured, and a peek at some common workflows. Along the way, we'll point you in the direction of more in-depth tutorials and resources, and we'll conclude with suggestions on how to take your budding Symphony skills to the next level.

Meet Symphony

Symphony is a web-based content management system (CMS) that enables users to create and manage websites and web applications of all shapes and sizes—from the simplest of blogs to bustling news sites and feature-packed social networks. With Symphony, you can build just about anything, and that's what sets it apart from most other CMSs. Instead of making all kinds of assumptions about your content and what you'll be doing with it, Symphony gives you the tools to make those decisions for yourself.

From its very beginning, Symphony has been engineered around principles like openness, simplicity, and standards-compliance. This approach has resulted in a granular architecture that's easy to customize at every level, and a clean, minimal core that's high on efficiency and low on bloat. It's also led to the adoption of open standards like XML and XSLT, which make the system more transparent and free it from constraints common to other CMSs.

Thanks to its unique development philosophy, Symphony's been designed to ensure that you'll have complete control over all aspects of your project, from the data model to the presentation layer and everything in between.

Understanding Symphony

Symphony, as we've seen, is engineered to be immanently flexible. It allows you to define the types of content you'll manage, the structures that will deliver that content to the front end, and the templates that will transform it into various formats for your users. Because Symphony gives you complete control over these fundamental building blocks, you could say it's as much a content management framework as it is a CMS. In some senses, every Symphony project is a custom CMS of its very own.

How does this work? Each layer of Symphony's content management infrastructure is comprised of distinct, fully configurable components. A project's content types are defined using sections and fields. Its pages provide dynamic front-end interfaces for viewing and interacting with that content. Data sources fetch and organize the content and deliver it to pages as XML, where page templates and utilities are applied to transform it into a desired format (HTML, for example). Advanced interactions, like data submission, can be enabled using events.

If you're familiar with the Model-View-Controller (MVC) pattern, that can be a helpful way to think about Symphony's structure. In MVC terms, sections and fields would be the model, page templates and utilities would be the view, and pages, data sources, and events would be the controller. Symphony gives you all the power of an MVC framework, but with the ease-of-use and elegance of a web-based CMS.

  • For a more in-depth tour of the system and how it works, see "Symphony Anatomy" (forthcoming).
  • To learn more about any of the system's specific components, explore the concepts section.

Using Symphony

For all its power and flexibility, using Symphony is remarkably easy. Let's walk through a fairly common use case: the blog. You'd start by creating a section called, say, "Blog Posts," and adding fields like "Title," "Body," and "Date." That quickly, you'd have modeled your first content type. After creating a test entry in Blog Posts, you'd want to be able to see it on the front end. So you'd create a page called "View Blog Post" with a URL handle of post, and configure it to accept a URL parameter called "title." Next, you'd create a data source to fetch from Blog Posts the entry whose title field matched the title parameter set in the page's URL. Finally, you'd whip up a quick page template to display your data source's result. Then you could visit http://yoursite.com/post/your-post-title to view any Blog Post entry in the system. Pretty neat, huh? So simple and yet the possibilities are endless.

As you can imagine, though, because Symphony gives users and developers so much freedom, planning a project requires a more deliberate approach than many other CMSs. You'll need to design your own data models, thinking carefully about the structure of your content and how different types relate to one another. You'll have to draw up an architecture and URL schema for your front end. And you'll need to map out how you want your content to flow through the system.

It's quite a bit of work, but the reward is that you end up with a system that's finely-tuned to meet your own specific needs. The extra effort you spend now will save you countless hours in the future, since you won't be constantly fighting against the whims of a cookie-cutter system. And luckily Symphony's modular architecture lends itself to rapid prototyping and development, making it easy to start with something small and focused and then build out your project iteratively. In other words, though you're advised to plan well, Symphony is agile enough to roll with the punches whenever your plans change.

  • Read more about "Planning a Symphony Project" (forthcoming)
  • Get a more detailed view of common "Symphony Workflows." (forthcoming)

Learning Symphony

This guide has provided only the briefest of overviews—but it's hopefully enough that you'll feel comfortable poking around a bit. As with most software, experimentation is really the best way to learn Symphony. Our growing collection of beginner tutorials is a great place to start.

Before you're ready to pursue a serious project, though, there are some additional bases you'll want to make sure you've covered:

  • Get a good grasp on XSLT basics (article forthcoming) so you can write clean, elegant templates.
  • Be sure you understand the various field types available and how they work, so you can design a good data model.
  • Familiarize yourself with all the options available when creating data sources, so you can be sure you're getting everything you need from your data.
  • Understand how parameters work so you can keep your project lean and dynamic.
  • Know what extensions are available. They can make your life a lot easier.
  • Register and spend lots of time in the forum. It's where most of your questions will get answered.
  • When you've got these fundamentals all figured out, learn how to go “Beyond the Basics”.

What Next?

The day will come when all of this information will have somehow been crammed into your brain, and you'll know Symphony so well that this Beginner's Guide will no longer be helpful. But fret not. For on that day, you'll have left the ranks of the beginners and noobs. You'll officially be a Symphony User. And, wouldn't you know it, there's a guide for users, too.

Important Concepts

Visual Overview

Symphony Visual Overview

Symphony • Open Source XSLT CMS

Server Requirements

  • PHP 5.3-5.6 or 7.0-7.3
  • PHP's LibXML module, with the XSLT extension enabled (--with-xsl)
  • MySQL 5.5 or above
  • An Apache or Litespeed webserver
  • Apache's mod_rewrite module or equivalent

Compatible Hosts

Sign in

Login details