GNU Tools Cauldron 2018

<< GNU Tools Cauldron 2017 | GNU Tools Cauldron 2019 >>


Organizing committee:


We are grateful to our sponsors for their generous support. Some have supported us for many years, others we are pleased to welcome for the first time this year. All contributing to maintaining a vibrant GNU tools community.

We shall soon be looking for sponsors for Cauldron 2019. Please email if you are able to help.

For all those who have asked about the logo, here it is:


Licensing and usage terms are the same as for the standard GNU head.

Slides, Videos and Notes

Mailing lists

  1. Abstract submissions, registration, administrivia questions:

  2. Announcements and discussions related to the conference: .

Workshop description

We are pleased to announce another gathering of GNU tools developers. The format of this meeting will be similar to the previous meetings. The purpose of this workshop is to gather all GNU tools developers, discuss current/future work, coordinate efforts, exchange reports on ongoing efforts, discuss development plans for the next 12 months, developer tutorials and any other related discussions.

This time, the GNU Tools Cauldron returns to the North of England, taking place in the Sackville Street building of the University of Manchester, adjacent to the Alan Turing memorial. Manchester University was one of the earliest centers of computer innovation, with Alan Turing serving as Deputy Director of the Computing Machine Laboratory from 1949. The Cauldron dinner will take place at the Manchester Art Gallery. For those who can arrive early, we have arranged a demonstration on Thursday afternoon of the 1948 Small Scale Experimental Machine (SSEM) which is housed at the Museum of Science and Industry.

We are inviting every developer working in the GNU toolchain: GCC, GDB, binutils, runtimes, etc. In addition to discussion topics selected at the conference, we are looking for advance submissions.


If you intend to participate, but not necessarily present, please let us know. Send a message to stating your intent to participate. Please indicate:

Please tell us as soon as possible if you need a letter of invitation in order to secure a visa.

Travel Grants for Students

The GNU Tools Fund sponsors student travel to attend the GNU Cauldron. Travel grants cover some or all of travel related expenses. This program is open to full time undergraduate and graduate students.

Students should email information about their interest, their experience, their participation in the GNU Toolchain, an estimated budget, and any sponsors in the GNU Toolchain community to

The deadline to submit a request is 1 August 2018.

Submitting talks/BoFs/tutorials

The program is now full for full presentations, BoFs and tutorials. We have room for a small number of additional lightning talks.

If you have a topic that you would like to present, please submit an abstract describing what you plan to present. We are accepting four types of submissions:

Note that we will not be doing in-depth reviews of the presentations. Mainly we are looking for applicability and to decide scheduling. There will be time at the conference to add other topics of discussion, similarly to previous meetings.

To register your abstract, send e-mail to .

Your submission should contain the following information:

Code of Conduct

All participants are expected to by the conference Code of Conduct. As in 2016, we shall use the British Computer Society Open Source Special-ist Group Code of Conduct.

GDPR compliance

The personal information we hold on you is your name, affiliation, dietary preferences, T-shirt size and whether you wish to attend the SSEM demonstration. This information will only be used to contact you about the arrangements for the GNU Tools Cauldron 2018, including a follow-up questionnaire after the event. The data is held securely on outsourced secure servers where the data is encrypted. The data is only accessible by the organisers of the GNU Tool Cauldron 2018. All the data will be destroyed shortly after the GNU Tools Cauldron, once the follow-up questionnaire has been sent out.

Please contact the Data Officer if you would like to know the information we hold on you, wish to have that information deleted, or for any other queries related to GDPR.


This is the schedule. Any problems, please email the organizers.

All events are in the Sackville Street Building, except where indicated.

The Great Hall seats up to 150, the C53 Lecture Theatre seats up to 137. In addition we have the Council Chamber (seating 40) for informal meetings, breakout and hacking (apart from some slots on Saturday afternoon when it is scheduled for BoFs). We shall use the Entrance Hall for the welcome reception on Thursday evening.

Last Minute Changes

The schedules will be on posters around the venue, and will be updated as necessary by the organizers. In addition last minute changes will be posted on the GCC IRC channel (#gcc on and tweeted with the hashtag #GNUCauldron.

Remote Access to Talks

In general we are not going to livestream the talks, although they will all be videoed and made available here shortly after the Cauldron concludes. If there is a talk where there are key remote participants, please let the organizers know as soon as possible and we'll do our best to set up a remote video connection.


Abstracts will be listed here in strict case insensitive alphabetical order of title.


(Ab)using LTO plugin API for system-wide shrinking of dynamic libraries

Speaker: Vladislav Ivanishin

In this talk I will recount our adventures in pruning globally unused symbols from dynamic libraries in a "closed-world" system.

We relied on GCC's and GNU linkers' plugin facilities to collect section/symbol dependencies, and downgrade unused symbols' visibility to hidden to enable the --gc-sections linker switch to eliminate them.

This talk will feature some pitfalls of the linker plugin API and linker bugs we stumbled across. We'd like to highlight that if third parties are welcome to use the linker plugin API it might need some fundamental changes to be really useful.

Our work was tested on a Tizen distribution, bringing a 16% reduction in total size of the binaries, which translated to a 10% reduction of the system image size.

This is a joint work with Evgeny Kudryashov, Alexander Monakov, Dmitry Melnik (ISP RAS), Jehyung Lee, and Chan Lee (Samsung Research).


Speaker: Andrew Stubbs

An overview of the GCN GPU architecture, how it creates challenges for a GCC backend, and how we've chosen to solve them.

What's done, and what's still to do.

OpenMP and OpenACC for GCN.

Comparing the IBM Z back ends in GCC and LLVM

Speaker: Ulrich Weigand

GCC and LLVM perform similar tasks, but the internal implementation is very different. As a maintainer of the IBM Z back end in both GCC and LLVM I've had the opportunity to become familiar with both worlds.

In this talk, I'll give an overview of the current status of support for IBM Z processors in both GCC and LLVM, touching on differences in available feature sets and performance results.

In addition, I'll be talking about my experience working in the context of both compiler frameworks. Where did I find GCC easier to work with, and where does LLVM have its advantages? The talk will look at these questions from a back-end perspective.

A collection of debug info improvements for the GNU Compiler Collection

Speakers: Mark Wielaard & Alexandre Oliva

DWARF is designed to have limited dependency on tools. A linker just has to concatenate the data sections, resolve symbol and inter-section relocations. But that does cause lots of repeated data structures (types) and the linker has to process a lot of references/relocations. To counter that .debug_types and DebugFission were introduced. First as GNU extensions then added to DWARF4 and DWARF5. Lots of details changed. These techniques can be used with separate .dwo files, or since DWARF5 in each .o file. This does introduce some extra complexity. We have to add various levels of indirection for types, strings, addresses and inter-section references. And with split-dwarf between the .o object files, executable and .dwo files. Some of the de-duplication of data is pushed to the DWARF consumer, or might need a slightly smarter post-processor to merge the duplication of types and data (there can be thousands of split-dwarf .dwo files).

We will go over the techniques that are now implemented in GCC. Which versions of GCC implement what. Why the indirection tables are actually cheaper than traditional relocations. Where they aren't used yet, but probably should. The current state of DWARF consumers (gdb, elfutils, etc.) and auxiliary post-processing tools (dwp and dwz).

In another part, the topic will be the latest and next steps in our efforts to improve debug information of optimized programs, so as to make debugging and monitoring possible without disabling optimization and recompiling. We have gone through each of the optimization passes in GCC enabled by -O* flags and assessed their impact on debugging (study of -O* vs -g, thus gOlogy :-), and how successful such techniques as source loci in stmts and insns, var-tracking, VTA, SFN, and LVU have been at masking the unwanted effects of optimizations. Presenting the complete results of the report would take far too long (it is way over a hundred different passes!), but we will present highlights that point at future projects, from low hanging fruit to large undertakings.

Future Direction of OpenACC

Speaker: Cesar Philippidis

This talk will present a high-level overview on the current state of OpenACC support to be included in GCC 9. Next it will cover the new functionality for GCC 10 and beyond. New functionality includes, but not limited to, enhancing automatic parallelism in OpenACC kernels and deep copy.

GDC - D front-end for GCC

Speaker: Iain Buclaw

The D programming language, what is it and who is it being used by?

The D front-end for GCC was started in 2004, and has been actively maintained for the last ten years, will talk about how it was implemented, and what features of GCC it makes leverage of.

The D language was accepted for inclusion into GCC, what is being currently done for that?

What is the currently being worked on in GDC, and status of moving to a self-hosting front-end.

Implementing static analysis checkers in the middle-end

Speaker: Martin Sebor

An overview of benefits and challenges of implementing warnings in the GCC middle-end. Using specific examples I will go over some of the disadvantages of front-end warnings and show how they can be overcome by relying on control- and data-flow analyses in the middle-end. I will go over some of the biggest technical as well as social challenges in achieving acceptable ratio between false negatives, false positives, and true positives.

Long double format on GLIBC for powerpc64le

Speaker: Gabriel F T Gomes

Long double can take many formats. On POWER, it can take the same format as double, or the IBM Extended Precision format, which is currently default on all POWER latforms. More recently, the GLIBC community introduced library support for an additional floating-point type (_Float128), which lays the groundwork for the transition of the long double type to its new format, on powerpc64le.

The transition is currently being developed for GLIBC and is comprised of several goals and challenges:

This presentation will share the design options and rationale for choosing among them, as well as aiming to collect more feedback from the community.

Optimization records: showing the user what GCC's optimization passes are doing

Speaker: David Malcolm

How does an advanced end-user figure out what GCC's optimization passes are doing to their code, and how they might tweak things for speed?

How do we (as GNU toolchain developers) debug and improve the optimization passes?

I'll be talking about:

Optimizing math routines

Speaker: Szabolcs Nagy

This talk presents the work behind several new single and double precision math function implementations for glibc.

The new implementations are generic and the performance improvements should be portable across different targets. The main challenges were dealing with target variations, rounding errors, doing careful error analysis, following the requirements of various standards, testing and benchmarking different configurations, integrating the code into glibc and fighting with various tools. I plan to discuss these challenges and some of the design decisions behind the new code. The performance improvements are significant in most cases so it is also worth discussing the key ideas that made it possible.

Some of the patches were upstreamed last year, some are still under review, the list of optimized functions with ubenchmark performance improvement on common inputs: sinf (1.7x), cosf (1.7x), sincosf (1.7x), expf (3.5x), exp2f (3.1x), logf (2.3x), log2f (2.4x), powf (4.8x), sin (1.4x), cos (1.4x), sincos (1.7x), exp (1.9x), exp2 (2.0x), log (3.8x), log2 (2.0x) and pow (3.1x).

PowerPC GCC memory handling changes

Speaker: Michael Meissner

In this talk I will discuss changes that I am working to rework the PowerPC GCC compiler memory support to handle memory addresses in a more general fashion. The idea is to not immediately split addresses into the instructions that will ultimately be used to address memory, but keep the addresses together longer in the RTL stage of the compiler. I will also discuss how this plays into supporting fusion that some of the PowerPC servers support.

Progress With C++ Modules

Speaker: Nathan Sidwell

The C++ modules-ts [1] is now published, but undergoing design changes as implementations progress. I shall cover the progression of the design, and of the implementation in G++[2].

This talk will provide background to the C++ Modules & Tooling Tutorial.

The SECURE project and GCC

Speaker: Graham Markall

The SECURE project is a 15 month program funded by Innovate UK, to take well known security techniques from academia and make them generally available in standard compilers, specfically GCC and LLVM. An explicit objective is for those techniques to be incorporated in the upstream versions of compilers. The Cauldron takes place in the final month of the project and this talk will present the technical details of some of the techniques implemented, and review those that are yet to be implemented. A particular focus of this talk will be on verifying that the implemetnation is correct, which can be a bigger challenge than the implementation.

Techniques to be covered in the project include the following:

Towards Clear Memory Object Semantics for ISO and De Facto C

Speaker: Peter Sewell

The semantics of pointers and memory objects in C has been a vexed question for many years. C values cannot be treated as simple abstract or concrete entities: the language exposes their representations, but compiler optimisations rely on analyses that reason about provenance and initialisation status, not just runtime representations. The ISO standard leaves much of this unclear, and in some aspects differs with de facto standard usage - which itself is difficult to investigate.

This talk will describe the issues involved in defining a clear source-language semantics for pointers and memory objects, focussing especially on pointer provenance. We aim ultimately to reconcile the ISO C standard, mainstream compiler behaviour, and the semantics relied on by the corpus of existing C code.

It will also describe how a proposed semantics has been made executable as a test oracle (to calculate all the semantics-allowed executions of small tests), by integrating it with the Cerberus semantics for much of the rest of C, and preliminary experimental work to assess what code out there depends on.

The talk will be a revised version of a keynote given at EuroLLVM 2018, informed by discussion with the recently created ISO WG14 C Memory Object Model Study Group. We would be very interested to get feedback from the broader GCC community about these issues.

This is joint work with Kayvan Memarian, Victor B. F. Gomes, Stephen Kell, Brooks Davis, Robert Watson, Alex Richardson, and members of the ISO WG14 C Memory Object Model Study Group.

Update on Modula-2

Speaker: Gaius Mulley

GNU Modula-2 has been grafted onto the trunc, 8.0.1, 6.4.0, 5.4.0, 4.7.4 and 4.1.2 releases of gcc. Several new options have been introduced, most notably, -fm2-g, -fwholevalue, -ffloatvalue and -fm2-plugin.

The option -fm2-g will guarantee an instruction for every statement compiled.

Integer arithmetic overflow detection for (subtract, addition, negation, multiply, assignment operators, for all ordinal operands and sub-range types. (-fsoft-check-all) and (-fwholevalue) is complete. Detection of a NaN after all floating point arithmetic operations is also available via -ffloatvalue.

The new plugin for Modula-2 exploits the optimisation and data flow analysis to provide enhanced semantic checking. Semantic compile time checking has been considerably enhanced by the new plugin which detects whether the initial basic block in any reachable procedure contains a runtime violation (a call to the runtime error library).

This works well as the runtime error library functions take source file, line, column as parameters. Thus this information will survive any optimisation and therefore data flow analysis coupled with code transformation optimisations can be usefully leveraged towards gaining better semantic errors.

Value-numbering on regions and beyond

Speaker: Richard Biener

The SSA SCC based value-numbering algorithm used by FRE and PRE isn't well suited to be applied to regions of code and cannot be made fully optimistic. Its implementation also has correctness issues with regarding to expression simplification.

A new RPO based algorithm tries to address all these issues. The implementation is designed to be of complexity of the region it is applied to, making it suitable as localized cleanup phase after transforms like loop unrolling. Given its RPO structure it can be switched between a non-iterating non-optimistic mode and a iterating optimistic one. Care is taken to do expression simplification using available SSA names rather than values to avoid the wrong-code issues the SCC implementation is plagued with.

Lightning talks

Maximum 10 minutes including Q&A.

Automatic Tuning of Compiler Options using irace

Speaker: Manuel López-Ibáñez

Co-authors: L. Pérez Cáceres, F. Pagnozzi, A. Franzin & T. Stützle

While modern compilers usually offer different levels of optimization as possible defaults, they have a larger number of command-line options and numerical parameters that impact properties of the generated machine-code. The irace package ( is a method for automatic algorithm configuration that can handle numerical and discrete options and optimizes their settings according to a given metric (such as runtime) over a large number of noisy (stochastic) benchmarks. When adapted to the tuning of compiler options in GCC, irace becomes an alternative to Acovea, OpenTuner and TACT with some desirable features. Experimental results show that, depending on the specific code to be optimized, speed-ups of up to 1.4 when compared to the -O2 and -O3 optimization flags are possible.

I'm presenting on behalf of the other authors who will not attend. They did all the experiments using our tool (irace) and advice from me. I hope the irace package will be interesting to GCC developers and users (it is GPL).

Dependence Analysis

Leader: Michael Matz

This is an introduction to the subject matter of the Dependence Analysis BoF.

GDB DWARF index cache

Speaker: Simon Marchi

DWARF index sections help significantly reduce the load time of large binaries in GDB. However, they require manual steps in order to be produced: either use a particular linker and set the right linker flags or run on the final binary. As a result, I didn't use them very often and didn't encounter them very often in the wild.

A recent feature allows GDB to automatically produce and save an index file to a cache directory when loading a symbol file that does not already have one. This lets the user take advantage of the speedup of the index for any binary (the next time they load the same binary), without having to even think about it.

We will see how to use this feature (spoiler: set index-cache on) and peek quickly in how it is implemented.

Using libgccjit as CTFE backend

Speaker: Stefan Koch

I am currently reimplementing the CTFE (Compile-time function evaluation) functionality of the D programming language's main compiler, DMD. I will explain why libgccjit makes this much easier, and why it shines compared to LLVM.

Using the GCC regression test suite for LLVM

Speaker: Simon Cook

LLVM has two main test suites:

However there is no large body of tests of detailed functionality which is compiled right down to the target object code and executed. We describe the changes we have made to allow the GCC test suite to be used for nightly public regression testing of LLVM for RISC-V.

Birds of a Feather sessions (BoFs)

Advocacy for GNU tools BoF

Facilitator: David Edelsohn

This is an opportunity for all interested to discuss how we can improve advocacy for GNU tools projects.

Arm/AArch64 BoF

Leaders: Ramana Radhakrishnan and Richard Earnshaw

The Arm and AArch64 BoF is an open session for discussing your issues and concerns on anything Arm related in the GNU toolchain. There is no fixed agenda!

We'll probably start with a brief overview of the work done in the past year and then focus on whatever seems to be the most interesting items within the group. If you have specific issues or questions that you wish to raise, it might help if you can notify us in advance so that we can try to ensure that there is time to cover it.

Topics that might be of interest this year:

Consistent use of atomics in libstdc++ across ARM targets

Leader: Jonathan Wakely

A few places in libstdc++ assume that the same -march value is used when building libstdc++ and when compiling user code that includes headers. If this isn't true you can get undefined behaviour and crashes (or worse). I'd like to clean this up so that it just Does The Right Thing, even for ARMv5 where there are no native atomics. I'd like to present the current problem and start a discussion about how to fix it, maybe via kernel helpers, or something in glibc.

Dependence Analysis BoF

Leader: Michael Matz

We're going to discuss some of our loop transformation infrastructure, namely dependence analysis, it's representation, possible reuse of the GRAPHITE implementation of it (separating it from its code generation aspect) for all our dependence analysis needs and related topics.

Future directions for treatment of undefined behavior in C

Leader: Alexander Monakov

I'd like to invite discussion on prospects of adjusting how GCC treats undefined behavior. There's ever-increasing interest in discovering UB in production code, with tools such as tis-interpreter and UBSan helping to detect UB at runtime, as well as various tools for static analysis. At the same time, GCC does not always produce diagnostics for users wishing to learn where the compiler assumes absence of undefined behavior, and optimizations don't always insert traps when unconditional UB is reached.

Possible topics for discussions include: new warnings for code that may or will exhibit UB at runtime; adjusting optimization to avoid amplification of UB effects as much as practical.

Gfortran Developers' BoF

Leader Thomas Koenig

A meeting of the gfortran developers.

OpenACC/OpenMP/offloading BoF

Leaders: Jakub Jelinek and Cesar Philippidis

Non-8-bit-byte architecture support BoF

Leader Simon Marchi

GDB currently has very patchy support for processor architectures with memories whose addressable size is other than 8-bits. One of the problems is that while such architectures exist as internal products at various companies, very few are publicly/freely available and none of them is supported by FSF GDB. It's therefore not possible for the community to test and maintain the GDB support for such architectures.

This BoF is intended to bring together those who deal with such architectures, discuss what can be done to consolidate the support for them and how to make it easy to test it. It would be interesting to find an architecture with non-8-bit-bytes memory for which support could be added upstream. Another interesting avenue to discuss would be the AAP project by Embecosm [1], which can be used to generate architectures with unorthodox memory configurations.

Power / PowerPC / rs6000 BoF

Leaders Segher Boessenkool & Bill Schmidt

BoF for all developers interested in the Power ports, discussing progress, concerns, and plans during the GCC 9 time frame. We will also provide a brief overview of the new POWER9 processors and their impact on our GNU toolchain development.


Leaders: Jeremy Bennett, Palmer Dabbelt, Jim Wilson

An opportunity to discuss all things related to the GNU tool chain for RISC-V

RISC-V Vector Extension Implementation BoF

Leaders Roger Espasa and Graham Markall

The RISC-V Vector Extension has several interesting properties. Two that are particularly interesting from a compiler perspective are:

The vector length being determined by the hardware is similar to ARM's Scalable Vector Extensions (SVE), but in SVE the vector length is fixed during program execution. Whilst it is possible to leave the configuration fixed throughout execution in RISC-V, tailoring the vector length and register file configuration will result in higher-performing programs.

This BoF is for discussion about changes to GCC to support the RISC-V Vector Extension and the challenges that it presents, such as the impact on optimizations that the configurable vector length and register file will have.

The GDB BoF & quick status update

Leader: Pedro Alves

An opportunity for the GDB community to meet to discuss all things related to the GNU Debugger project.

I'll start by showing some slides going over GDB's progress in the last year.

The GNU C Library BoF

Leaders: Carlos O'Donell, Florian Weimer

The GNU C Library is used as the C library in the GNU systems and most systems with the Linux kernel. The library is primarily designed to be a portable and high performance C library.It follows all relevant standards including ISO C11 and POSIX.1-2008. It is also internationalized and has one of the most complete internationalization interfaces known.

This BOF aims to bring together developers of other components that have dependencies on glibc and glibc developers to talk about the following topics:

… and more.


Leader: Jan Hubicka

Discussion about recent LTO and IPA developments in GCC.

The Multicore GDB BoF

Leaders: Pedro Alves, Stephen Roberts, Andrew Burgess

Discussion of all things related to multicore debug, particularly debugging multiple remote systems and bare metal multicore.

Unwinder BoF

Leader: Florian Weimer

Our current approach with unwinding has several problems:

There is a related discussion in in WG21 SG14 concerning alternatives to table-driven (“zero cost”) exception handling. See Herb Sutter, Zero-overhead deterministic exceptions: Throwing values.

The intent of the BoF is to discuss ways to address some of these issues, determine whether closer integration between the dynamic linker and the unwinder is needed, and get an early idea whether we want to switch away from table-driven handling for Sutter-style “throws” functions.


C++ Modules & Tooling

Speaker: Nathan Sidwell

C++ Modules require compilers & build system cooperation. How can that be achieved without one becoming the other? I'll present the evolution of schemes in the G++ modules project. I'll show why putting a client/server interface into the toolchain is not a crazy idea.

CGEN Tutorial

Leaders: Jeremy Bennett, Andrew Burgess & Ed Jones

CGEN hugely simplifies writing of assemblers, disassemblers and simulators, particularly for GNU tool chains. All generated from a Scheme specification of the ISA syntax and semantics.

In this tutorial we will introduce all the key features of CGEN as used within GNU tool chains. We'll use RISC-V and AAP as examples.

Q&A Sessions

GCC Steering Committee Q&A

Led by: David Edelsohn

Time: Sunday, 10:00-10:45, Great Hall (TBC)

Do you have questions? We may have answers. Or maybe not.


University of Manchester Sackville Street Building (main venue)

Sackville Street Building

The Grade II listed Sackville Street Building opened in 1902 to support the expansion of Manchester Municipal Technical School. Today it forms part of the University of Manchester, the second largest University in the UK.

Manchester Art Gallery (image CC-BY-SA David Dixon)

Manchester Art Gallery is home to major collections of Fine Art, Craft & Design and Costume. A chance to admire the artistic heritage of the city.

We plan a buffet feast of regional foods, which will be accompanied by beverages from local breweries and cider mills.

The Museum of Science and Industry (SSEM Demonstration)

The Museum of Science and Industry (image CC-BY-SA Jonti Wilde)

The Museum of Science and Industry celebrates Manchester's key role in technology development over the centuries and houses a replica of the 1948 Small Scale Experimental Machine (SSEM), aka the "Manchester Baby". We have arranged a demonstration for the Thursday afternoon. To make it feasible we have divided the time available into 4 slots. There should be a maximum of 22 people in each group.

Go through the main entrance of MOSI (it's free). There will be helpers from the Cauldron to point you towards the SSEM. Feel free to look around other exhibits while you are there.

About Manchester

Founded as a roman fort just under two thousand years ago, Manchester remained a small town until the start of the nineteenth century. With the start of the Industrial Revolution, Manchester expanded and urbanized rapidly and today is at the center of an urban area of more than two million people. Its key role in the Industrial Revolution generated great wealth, and the city is noted for its striking architecture from the period.

Where to eat

By popular request, here is a selection of restaurants local to the venue. There are far more available through your favourite mapping application.

Village Fish & Chip Shop

Northern Soul Grilled Cheese

Lively, fast food-style joint known for its inventive, elevated grilled cheese sandwiches.

Bagel Factory

Counter-serve bagel chain outlet that prepares sandwiches plus sweet and savoury snacks on-site.


Go Falafel

Colourful, modern takeaway serving menu of falafel wraps, hummus, juices and smoothies.

=== Arnero Restaurant ====

Mughlai and North Indian cooking are the speciality at this welcoming restaurant.

Habesha Restaurant

East African stews and delicacies at an Ethiopian restaurant with colourful decor and artefacts.

Molly House

Gay Village spot for tea, cocktails, Spanish/South American tapas and more, with a small verandah.

Phetpailin Thai Restaurant

Anglo-Thai cuisine in a Chinatown venue, including a wide vegetarian choice and no BYOB corkage.

Happy Seasons Restaurant



By Air

Manchester is served by Manchester International airport. Transfer time by train is approximately 15 minutes. For those arriving in London, there is a fast train service taking just over 2 hours from London Euston, giving a total transfer time from Heathrow or Gatwick Airports of around 3.5 hours.

Public Transport

The Sackville Street Building is 400m from Manchester Piccadilly station and is very well served by trains from the airport, London and many northern towns and cities. For timetables and travel planning see National Rail Enquiries.

The building is also a short walk from the Central Coach Station, offering coach transport to London and many other cities. For timetables and travel planning see National Express.

In addition to the long distance rail and coach network, Manchester has an extensive bus and tram network. Everything you could possibly want to know is available from Transport for Greater Manchester.


Numerous taxi companies as well as Uber serve Manchester. There is a public taxi rank at Piccadilly station where you can pick up a metered taxi.


Every major hotel chain is represented in Manchester, and there is a huge choice of smaller independent hotels, B&Bs and self catering accommodation. Manchester Visitor Information can provide detailed advice.


The UK is generally temperate, but well known for the variability of its weather. While September can often be pleasantly warm, it can also serve up autumn gales and rain.

None: cauldron2018 (last edited 2019-03-12 17:31:45 by SimonMarchi)