When I first started out in astrophotography, I remember squinting at a folder of strange .fits files and wondering what on Earth I had gotten myself into. After a long night under the stars with my telescope and camera, these files were the fruits of my labor - yet if you clicked on one, it looked like an almost black, empty image. In spite of their unassuming appearance, I soon learned that those FIT files were pure gold. Each one is like a digital negative of the object I just shot: an unstretched, uncompressed capture of every photon my sensor recorded. Unlike a blurry JPEG that maight pop out of a DSLR, a FIT file doesn't offer a preview at first glance. Instead, it holds all the precious data from your imaging session - every nuance of starlight captured, every detail about how and when the image was taken, all neatly packed away for you to uncover later. In a way, a FIT file is the truth of your astrophotography session. It's the direct result on the right side of the equation after you've spent hours setting up gear in the cold, polar aligning, focusing, and guiding on a faint galaxy. All that effort lives on in these raw files.
But what exactly is a FITS astrophotography file, and why do seasoned astro-imagers like me swear by it? Let's dive in and explore the origins of this format, what's inside it, and why after understanding it, you might never want to capture the night sky as a simple JPEG (JPG) again.
First things first: FIT (usually written as "FITS" with an S) stands for Flexible Image Transport System. Despite the name sounding like something to do with shipping boxes, it's actually about transporting data, specifically, astronomical data. The FITS format was born out of necessity back in the late 1970s. Back then, astronomers around the world were starting to gather more digital data from telescopes, and they ran into a big problem: every observatory and every instrument had its own way of formatting image data. Sharing a sky image from one research team to another could turn into a nightmare of incompatible tapes and proprietary formats. In 1979 a group of astronomers decided enough was enough, and they collaborated to create a universal file format that everyone could use. By 1981, the first definition of the FITS format was published, and in 1982 the International Astronomical Union (IAU) officially endorsed FITS as the standard for astronomical data exchange. This was a huge deal - imagine getting NASA and observatories worldwide to all agree on one format! But they did, and FITS has been a cornerstone of astrophotography and astronomical research ever since.
The name “Flexible Image Transport System" truly reflects its purpose and design. It's flexible because it was built to handle all kinds of data (not just pictures of stars, but any scientific arrays or tables). It's for images, broadly speaking - not only pretty pictures, but also things like spectra or electron counts that might not look like a traditional photo. It's meant for transport, highlighting that one of the primary goals was easy interchange of data between different computers, observatories, or researchers. And of course, it's a system - more than just a simple image file, it's a whole standardized way of storing information. Early FITS files were even designed to fit nicely on the magnetic tapes of the era (yes, those big reel-to-reel tapes were how data traveled in 1981). Over the decades, the FITS standard has been updated a few times (for example, to support new features like tables of data or larger images), but a crucial rule was established from the start: new versions must always be backward-compatible. In other words, a FITS file from 1985 should still open just fine in software today, and a modern FITS file still follows the core rules set in the ‘80s. That commitment to stability and compatibility is one reason FITS has survived and thrived for over forty years.
So, FITS is more than just another image format - it's a standard that underpins how astronomical data is saved and shared. When we say something is “the standard” in astronomy, we mean that virtually every professional in the field recognizes and uses it. The FITS format is formally endorsed not only by NASA but also by the IAU and other major scientific bodies. This widespread adoption means if you discover a new comet and save the image in a FITS file, you can send that file to an astronomer on the other side of the world and they'll be able to open it without a hitch. In the astrophotography community, we sometimes take for granted that our software just knows how to handle these files - that's the power of a good standard.
What makes FITS such a reliable backbone for astro-data? A big factor is that it was designed for science from the ground up. Unlike formats such as JPEG, PNG, or TIFF that were created with general photography or graphics in mind, FITS was created by astronomers specifically for astronomical needs. This means it accounts for things like preserving exact numerical precision of pixel values, storing calibration data, and even carrying coordinate systems for the sky. In practical terms, the FITS standard dictates a lot of rules to ensure consistency: for example, how information in the file is structured, how numbers are represented, and how metadata (like exposure time or telescope used) is recorded. By adhering to these rules, any FITS-compliant software can read the file and know exactly where to find the image data and what the accompanying information means.
Another key aspect of the FITS standard is its longevity. Remember that rule of always being backward-compatible? FITS was intended to be an archival format - something you could tuck away in a research library or your personal hard drive (use SSD) and still have and use decades later. Many of us have went back to our FITS data to re-process old image files using newer techniques. And yes, astronomers today still pull up FITS files from the 1980s and 1990s and get useful data from them. This is possible because the standard is well-documented and maintained by a working group that carefully considers any changes. In fact, the core structure of FITS hasn't fundamentally changed since the ‘80s; instead, it's been extended in ways that don't break older files. For example, new types of data (like multi-image stacks or complex spectral data) were accommodated by adding extension schemas, but the “once FITS, always FITS”rule means older software might not use the new features but will still recognize the parts of the file it understands.
From a more philosophical perspective, FITS matters because it ensures that astronomical data remains accessible and usable. If each telescope or camera manufacturer used a proprietary format, we'd all be constantly converting files and worrying about lost information (or worse, losing data if a company went out of business and their file format became unreadable). FITS being open and standard means it doesn't belong to any one company, it belongs to the community. In a way, it's part of the scientific commons. Even outside of professional astronomy, this benefits us astrophotographers: we're able to use a variety of software tools in our workflow and they all speak FITS. Your stacking program, your processing software, your plate-solving tool - they can all share the same FITS files. The standardization greases the wheels of our entire imaging process.
Okay, so FITS is a respected format in the science world, but why should you, the astrophotographer out in your backyard, care about it? The short answer: if you want the best quality and the most capabilities out of your images, FITS is your friend. Let's unpack that in practical terms.
When you use a dedicated astronomy camera (like a cooled CMOS or CCD camera), chances are the software that controls it saves images directly as FITS files. This isn't an accident or quirk - it's because those cameras are designed for capturing scientific-grade data. Unlike a consumer camera that might output a polished JPEG, a scientific astro camera funnels the raw sensor readings straight into a FITS file. Every bit of dynamic range the sensor is capable of, every faint signal above the noise, gets recorded. If you've used a DSLR or mirrorless camera for astrophotography, you might already be familiar with the advice “shoot RAW, not JPEG”. That's because RAW files from the camera retain more bit-depth and detail than the compressed JPEG. Well, think of a FITS file as an even more “raw” RAW. It can store data with extremely high bit-depth (16-bit, 32-bit, even 64-bit pixel values if needed) without throwing away a thing. In fact, one astro-imager friend of mine likes to call FITS the “super raw” format - it's as raw as it gets.
Another big reason FITS matters is metadata, the extra information stored alongside the image. When you open a FITS from your telescope, the file isn't just pixels. It often contains a treasure trove of details about how that image was taken. Exposure duration, the exact time and date, the camera gain or ISO setting, the sensor temperature, the filter used, the telescope coordinates pointed in the sky (right ascension and declination), the observatory location - potentially all of that can be recorded in the FITS header. This is incredibly useful. For one, it helps you later recall what you did (ever come back to an image weeks later and wonder “wait, was this a 5-minute exposure or a 3-minute one, and did I use the H-alpha filter or the luminance filter?” - the FITS knows!). It also is crucial for scientific uses: for example, if you capture a supernova and want to report it, the FITS can provide the precise timestamp and pointing needed for verification. Even as an amateur, you might use the metadata for things like plate solving - the process of identifying exactly what part of the sky is in your image. Plate solving software can write the celestial coordinates into the FITS header, effectively tagging the image with a map of the stars. Later, you (or anyone you share the file with) can load that FITS into a planetarium program or analysis software and overlay catalogs to identify every object in the frame. Try doing that with a plain JPEG - it simply doesn't carry that kind of information.
FITS is also widely used by the best in the business. NASA, ESA, and other space agencies release their astronomical images and data in FITS format. If you download a raw image from the Hubble Space Telescope or the new James Webb Space Telescope, you'll get a FITS file. The same is true for images from Mars rovers, lunar orbiters, and many other scientific instruments (though some use other specialized formats, but many ultimately convert to FITS for analysis). The point is, using FITS puts you in good company. It's the format of record for serious imaging. When I realized that my humble backyard images shared a format with the Hubble data I admired, it gave me a bit of a thrill - and more importantly, it assured me that I wasn't losing any information in my own images. I knew I had the maximum signal my camera recorded, stored in a way that scientists trust for their most important data. For anyone aspiring to improve their astrophotography, adopting the FITS format is almost like a rite of passage. It signals that you're treating your data with the same care that a professional would.
Lastly, consider longevity and reusability of your work. As we discussed, FITS files from decades ago are still usable today. When you save your hard-won night sky images as FITS and back them up, you're investing in the future. You might process a nebula photo today and get a decent result, but two years from now you'll have learned new techniques or maybe bought better processing software. If you have the original FITS file (and calibration frames), you can reprocess from scratch and potentially pull out more detail or correct mistakes from the first time. If all you kept was a processed JPEG, you'd be stuck - you can't really un-compress or un-stretch a JPEG to get back to the raw data. In that sense, FITS files keep your options open. They are like a time capsule of the exact data you captured, waiting for you to use it in new and better ways as your skills and tools improve.
Now that we've established how important these files are, let's pop open the hood and see what's actually inside a FITS file. You don't need to be a programmer or a data scientist to appreciate this, I'll keep it accessible. A FITS file is divided into sections called HDUs (Header Data Units). At minimum, there's a primary HDU which has two parts: a header and the data. Think of the header as the table of contents and notes, and the data as the main content (the pixel values for an image, for example).
The header is one of the coolest things about FITS. It's plain text, yes, human-readable text structured in a very specific way. If you were to open a FITS file in a simple text editor (I don't actually recommend editing it that way, but just for illustration) you would see a bunch of lines of text in all-caps, looking something like:
EXPOSURE= 300.0 / Exposure time in seconds DATE-OBS= '2023-07-14T02:30:00' / Observation date TELESCOP= 'Celestron 8in' / Telescope used XPIXSZ = 4.8 / Pixel size in microns (X) YPIXSZ = 4.8 / Pixel size in microns (Y) ... etc ...
Each of those lines is called a keyword record. It's formatted exactly 80 characters long (a charming throwback to the days of punch cards and fixed-width storage). The part before the = is the keyword name (like EXPOSURE or TELESCOP), and after the = is the value and an optional comment. The header will contain dozens of such entries, covering everything from the image dimensions and data type, to who captured it or what object it's pointed at (if you or the software added that info). Some keywords are standardized and appear in practically all FITS (like BITPIX which tells how many bits per pixel, or NAXIS which tells the number of axes/dimensions in the data). Others are custom - for instance, your particular capture software might add a GAIN keyword for the camera's gain setting, or a FILTER keyword to note you used an H-alpha filter, etc. The header is basically metadata heaven. It carries the important context for the image data that follows. This is what one astrophotographer meant by calling a FITS file a “very accurate written description of an image” - the header describes what the data represents, in great detail.
Following the header (which has a mandatory end marker so the software knows when header info stops), we get the data block. If it's an image, this data block is essentially an array of numbers, the brightness values for each pixel. In a typical deep-sky astro image, the data might be a 2D array (like 3000 x 2000 pixels, for example) of integer values. Each value might be, say, a 16-bit number ranging from 0 to 65535, representing how many counts of light were detected at that pixel. If the file is from a monochrome camera through a single filter (or a luminance shot), then it's one 2D array. If it's a color image in one file, FITS can represent that a couple of ways: one common way is to have a 3D data cube, essentially an array with a third axis of size 3 (for R, G, B channels). Another way sometimes used is multiple HDUs - e.g. one image extension for red, one for green, one for blue, each with its own header. In practice, many astrophotographers working with one-shot-color cameras save the raw Bayer data as a single array (appearing grayscale until processed), and many processing programs will store combined color images as 3-layer FITS. The key point is, the image pixel data is stored without compression or loss. The values in the FITS file are exactly what came out of the analog-to-digital converter on your camera at the time of readout (unless you intentionally applied some processing before saving, which typically we do not for raw frames).
Some FITS files can contain more than one image or data set. For example, there could be a primary image and then additional HDUs that contain things like a mask, a thumbnail, or a table of star measurements. In professional astronomy, FITS is often used to bundle related data together. However, for most of our uses in astrophotography, we're dealing with one main image per file. Calibration frames (darks, flats, etc.) are also usually separate FITS files for each frame. Stacked results might be saved as FITS too - for instance, after stacking 100 sub-exposures, you might end up with one integrated master FITS image.
It's worth noting that the most important parts of a FITS file for us are the header keywords that matter for processing, and the pixel data itself. Critical header info includes things like exposure time (EXPTIME or similar) which many stacking programs use to scale calibration, or the DATE-OBS which could be important if you're combining data from multiple nights. The pixel data is obviously the star of the show (pun intended): those numbers are what you will stretch and tease out to reveal the beauty of a nebula or galaxy. Because FITS stores them with high precision, you can perform heavy processing without the data falling apart. For instance, increasing brightness, adjusting curves, subtracting sky background - all these can be done on the FITS data with minimal numerical error creeping in.
In summary, inside a FITS file you have a rich description of your image and the raw image data itself. It's like a well-organized journal entry combined with a canvas of measurements. This dual nature - data + description - is what makes FITS so powerful for anyone who wants to do more than just glance at a pretty picture, but rather to really work with their image data.
By now you might be thinking, “Alright, FITS keeps everything, that's great - but why do my images look so awful when I first open them?” If you've opened a raw FITS from your camera in an astro-imaging program, you've likely seen something that looks almost entirely black or perhaps just a faint smattering of stars. This is completely normal, and it's actually a good sign! It means you are looking at the linear raw data, just as the sensor saw it. In a FITS file, the pixel values are proportional to the number of photons (light particles) counted by each pixel. The key word here is linear - if a star is recorded as 1000 counts and another star is 500 counts, the first star received exactly twice as many photons as the second (ignoring things like noise). This linear relationship is fundamental for doing proper calibrations and combining images. However, our eyes and brains don't perceive brightness linearly, and our computer screens have a limited range, so a raw linear astrophoto will look extremely low contrast.
An example of raw vs. stretched image data: the left panel is an unmodified linear FITS image, which appears almost completely dark (the objects is barely visible). The middle and right panels show the same data with different stretch adjustments, suddenly revealing the faint details that were hidden.
When you capture something like a galaxy or nebula, most of the pixels in your image have very small values, the background sky might be just a few counts above zero in each pixel, and the nebula might register slightly more. Only perhaps a bright star or the core of a galaxy has a high value. In a 16-bit range (0 to 65535), you might find that 90% of your pixel values are in the range 0 to, say, 1000. Displaying that on a screen where the maximum white is 65535 means everything looks nearly black. This is why, in astrophotography, we talk a lot about “stretching” the image. Stretching means applying a non-linear transformation (like raising the values to some power, or using a histogram curve) to boost the visibility of faint details without blowing out the bright parts. When you see a gorgeous image of a nebula online, know that the original data probably looked almost completely dark until it was stretched appropriately.
Most astrophotography software will apply a screen stretch automatically when previewing a FITS, just so you have something to look at on screen. This doesn't change the data in the file; it's like a temporary display adjustment. Different programs have different default stretches - one might make the image appear quite contrasty, another might keep it a bit darker, which can confuse beginners. For example, you might open the same FITS in two programs and one shows more of the nebula than the other; that's usually because their preview settings differ. The data itself is unchanged - if you equalize the stretch, they'd look the same. This is an important point: don't panic if your raw FITS looks blank or ugly. It's actually supposed to; all the “magic” is still in there, it just needs to be coaxed out with processing.
In contrast, consider what happens with formats like JPEG (or even the in-camera preview of a RAW on a DSLR). The camera or software has already applied a tone curve and boosted the brightness so that it looks nice and balanced to the eye. That's fine for casual photography, but for our purposes it's a one-size-fits-all stretch that often clips data. Clipping means that some faint differences might have been crushed to pure black or some highlights blown to pure white during that automated stretch. Once clipped, that information is lost forever. FITS avoids this by never pre-stretching or compressing the pixel data. It hands you the pristine, linear data. Yes, that means you have to do the work of stretching later on your computer - but it's work that gives you full control over the final result. You can apply careful curves, do multi-stage stretches, use methods like histogram equalization or gamma adjustments tailored to the specific image, etc., all because you have the raw material intact.
One way I like to think of it is to imagine a dark room with furniture in it. If you walk in straight from bright sunlight, the room looks pitch black and you can't see anything. But as your eyes adjust (or if you turn on a gentle light), gradually you can make out the shapes of chairs and tables and all the objects in the room. The objects were there all along; you just needed the right conditions to see them. Similarly, the nebula or galaxy in your FITS file is there in the numbers - you just need to adjust the “lighting” by stretching the histogram to reveal it. This process is part art and part science, and every astrophotographer develops their own preferred way to do it. The bottom line is, the raw data looks dark because it's honest. It hasn't been cosmetically enhanced yet. This honesty is exactly what we need to do rigorous processing and bring out the true beauty of the cosmos without artifact or loss.
The difference really boils down to quality and flexibility. If you've only ever used JPEG in the past, making the switch to capturing and processing from FITS can feel like night and day - and I'm not just saying that to be dramatic.
First, consider bit depth and dynamic range. A standard JPEG image uses 8 bits per color channel, which means pixel values go from 0 to 255. That might sound fine, but in astrophotography we often deal with extreme dynamic range (think of a bright star next to a dim nebula) and very subtle gradations (smooth transitions in faint dust clouds). An 8-bit depth can only represent 256 levels of brightness per channel, which is easy to exhaust when you start stretching the image. That's when you see “banding” - those ugly stairstep artifacts in what should be a smooth sky background - or you find that dim detail simply disappears because it was coded to the same value as the background. A FITS image, on the other hand, is typically saved with at least 16-bit depth (65,536 levels), and often more. Many astro cameras use 16-bit analog-to-digital converters, and some high-end ones use 12-bit or 14-bit which are then scaled or stored in 16-bit containers. Additionally, if you stack images or process in software, you might end up using 32-bit floating point representation to preserve even finer differences. FITS can handle all of these with ease. TIFF format, often used in regular photography for high quality, can also do 16-bit (and even 32-bit float in some cases), so TIFF isn't bad in terms of bit depth. But FITS still holds an edge in that it's designed to go arbitrarily high precision (32-bit float is standard in many FITS workflows; you could even save as 64-bit double precision if you needed to, which is overkill for images but illustrates the flexibility).
Now let's talk compression. JPEG is a lossy compressed format - it achieves smaller file size by literally discarding information, especially in areas of the image it thinks are less important. Starry night skies and faint nebula detail unfortunately often fall victim to this, because the compression algorithm might treat gentle gradients as something it can approximate and toss out fine variations as “noise.” The result is the notorious JPEG artifacts: blocky patterns or muddled blotches, especially when you zoom in or push the processing. FITS by default is uncompressed. What you save is exactly what you get back. There are options to compress FITS files using lossless methods (so they take up less disk space but expand back to the same data), and those are used sometimes when archiving huge data sets. But you will never find a FITS that has the kind of compression artifacts a JPEG has. Similarly, a TIFF can be saved uncompressed or with lossless compression (like LZW). So TIFF and FITS are on more equal footing there - both can retain all data without loss. The difference is that if you're using a typical DSLR or mirrorless camera, the “RAW” files (CR2, NEF, etc.) often use a form of lossless compression internally (to reduce file size) which is fine, but the camera always also generates a quick JPEG for preview that is heavily processed. Many beginners unfortunately have tried to stack those camera JPEGs instead of the RAWs and ended up with poor results. The lesson: always work with the raw data (FITS or equivalent), never the cooked JPEG, if you want the best image.
Calibration and post-processing workflows strongly favor FITS (or raw) over JPEG. When you calibrate images (subtract dark frames, apply flat fields, etc.), you are performing mathematical operations on pixel values. If those pixel values have been rounded off or quantized harshly (as in an 8-bit JPEG), the calibration will be far less accurate. In fact, applying a bias/dark subtraction to a JPEG can yield bizarre results because the black level and scaling might have been altered by the camera's processing. A FITS contains the linear sensor data, so subtracting a master dark frame (also in FITS) will properly remove the thermal noise pattern. The outcome is much cleaner and more reliable. Likewise, when aligning and stacking images, working with the full fidelity data means the stacking algorithm can weigh and average pixel values with far greater precision, leading to a cleaner combined image. If you stack JPEGs, you tend to stack also the compression noise and quantization error inherent in them, which doesn't average out nicely - it often shows up as residual artifacts.
Another scenario to consider: faint detail enhancement. In astrophotography, we often push our data to reveal the dimmest structures - for example, the outer wisps of a galaxy or the tendrils of a supernova remnant. Pushing a JPEG is like trying to sculpt with wax that's already half-melted - it gets messy fast. You'll see posterization (where smooth gradients become patches of a single color), and the color balance can skew because the camera's JPEG engine made certain assumptions that may not hold under extreme stretching. Pushing a FITS (or a 16/32-bit TIFF) is more like sculpting with high-quality clay - the data can bend quite a bit before it breaks. You can apply strong curves, local contrast enhancements, deconvolution, etc., and the data responds because those subtle differences between one pixel and the next are still present in the numbers.
I should mention camera RAW files (like .CR2, .NEF) versus FITS briefly, because many beginners start with DSLR RAW files. Camera RAWs are indeed much better than JPEGs since they keep a lot of data (typically 12-14 bit, sometimes up to 16 bit, and use lossless compression). In many ways, working with a camera RAW in astrophotography is analogous to working with FITS - and in fact, many astro software will let you import camera RAWs and will internally treat them much like FITS after converting. So what's the difference? One difference is that camera RAW formats are proprietary (each manufacturer has its own structure and metadata style), whereas FITS is a universal open format. Another difference: when you use dedicated astro software (like a guiding or capture program), if it can save in FITS, it might include extra metadata that a generic camera RAW wouldn't have (like telescope info or sensor temperature). Also, converting a camera RAW to FITS can sometimes make things easier if you plan to use multiple programs - FITS being the lingua franca, you reduce chances of incompatibility. I recall a friend who shot with a Canon DSLR; when he switched to processing in PixInsight, he set the software to convert all his CR2 files to FITS upon input. The results were the same image-wise, but now all his files had consistent headers and he could easily add his own notes or plate-solving results into the FITS headers.
In summary, using FITS (or at least a full-quality raw format) is about preserving every ounce of quality. It's the difference between a meticulously recorded symphony and an FM radio recording of the same, sure, you'll hear the music in both, but one will have depth and subtlety that the other lacks. If you take the time to gather photons from distant galaxies, you owe it to yourself to capture and process them in a format that doesn't throw any of them away. This is why, once astrophotographers experience the control and fidelity of FITS, they don't go back to using JPEG for anything except perhaps quick social media shares. By keeping to FITS through the edit process, you ensure that the final image you produce is as rich and detailed as possible. And if needed, you can always export a JPEG at the very end for emailing to friends or posting online - but that JPEG will be based on an image that was lovingly crafted from high-quality source data.
It's not just us hobbyists geeking out over FITS files, this format is truly ubiquitous in the astronomy world. Let's paint a picture of the spectrum of users. On one end, you have someone like me: a backyard astronomer with a telescope, a modern CMOS astro camera, and a laptop. Every time I click “capture” on my imaging software, I get a FITS file saved. On the other end, imagine the command center of the Hubble Space Telescope or the archives of a major observatory like the European Southern Observatory (ESO). The images and data coming from those big observatories? Stored and shared as FITS too. In fact, many of the incredible space images you see in magazines or online started life as FITS files that NASA or ESA released to the public, which were then processed (often using the FITS Liberator tool or similar) into the colorful JPEGs you finally see.
NASA is a huge user of FITS. Not only for optical images, but for all kinds of data: X-ray images from Chandra Observatory, infrared maps from Spitzer or JWST, radio data from missions - they all use FITS because it's so well-suited to scientific multi-dimensional data. Universities and research institutes around the globe have terabytes upon terabytes of FITS files stored, from both historic observations and current projects. If you were to step into a professional astronomer's office and look at what's on their computer, you'd see libraries of FITS files being analyzed with custom software (often written in Python with libraries like Astropy, or older tools in Fortran/C that also read FITS).
Now, let's bring it closer to home. Amateur astrophotographers who have moved beyond the very beginning stages will almost inevitably use FITS. If you're using software like PixInsight, AstroPixelProcessor, DeepSkyStacker, Siril, Maxim DL, Nebulosity, or countless others geared toward deep-sky imaging, FITS is usually the default choice. Even planetary imagers, who often capture video files (SER or AVI format) for lucky imaging, may convert their final stacked images to FITS for further processing or analysis (especially if doing things like measuring planetary detail or astrometry). There's also a subset of amateurs who do scientific projects like variable star photometry, asteroid hunting, or supernova searches. These folks absolutely rely on FITS because the precise measurements and metadata are crucial. Organizations like the AAVSO (American Association of Variable Star Observers) accept data in FITS, and many citizen science projects (like searching exoplanet transit data) provide data as FITS files.
Educational and outreach programs also leverage FITS. For example, some high school and college astronomy courses will have students work with real astronomical FITS images (perhaps from a small campus observatory or remote telescope) to learn data analysis. There are even user-friendly tools and image viewers (like the FITS Liberator, or specialist viewers like SAOImage DS9 for more advanced use) that allow the public to explore FITS data from famous observatories. I remember the first time I downloaded a FITS of the Eagle Nebula (the Pillars of Creation) from Hubble's archive - it was just a grayscale FITS file for one filter, not the color-composited thing you see in press releases. Viewing and stretching that FITS myself on my computer gave me a profound appreciation of how those images are made, and it felt like I had a direct connection to the telescope.
It's interesting to note that outside astronomy, FITS isn't very common. It was truly a format made by astronomers, for astronomers. There have been a few instances of other fields adopting it (perhaps some medical or microscopy data might use it, since it can handle multi-dimensional data well), but by and large, if you mention “.fits file” to someone, they'll either respond with “Oh, like astronomy images?” or they'll have no idea. And that's fine - we have our special tool that fits our special needs. The key point for someone getting into astrophotography is: you're adopting the same format that the experts and big observatories use. It's a nice common language between amateur and professional astronomy. In some cases, amateurs have even contributed data to pro research (for instance, during global events like eclipses or when pros need lots of eyes on transient phenomena). When they do, sharing FITS files ensures the scientists can actually use the amateur's data in their analysis pipeline.
So, who uses FITS? Everyone in astronomy who cares about their data. From a retired engineer imaging galaxies in his backyard, to a grad student analyzing star cluster images, to the team operating the James Webb Space Telescope a million miles from Earth - they're all dealing with FITS files at some stage. Knowing this should give you confidence that by learning how to use FITS, you're learning the real deal. You're stepping into a stream of practice that flows from small telescopes to the giants, and you can take comfort that the techniques and tools you pick up will scale as far as you care to take them in this hobby (or career, if you go that way).
At some point, you might wonder: “What if I want to use my images in other software or share them? Can I convert my FITS to something else, and what happens if I do?” The short answer is: yes, you can convert, and it's often necessary for certain purposes - but you should always keep your original FITS files backed up. Let's break down two common conversions: to TIFF and to XISF.
TIFF (Tagged Image File Format) is a popular format for high-quality images. It's widely supported in general photo editing software like Adobe Photoshop, Lightroom, and others. Many astrophotographers will do their stacking and initial stretching in an astro-specific program (working with FITS), and then at some point export a 16-bit TIFF to do final touch-ups in Photoshop (perhaps for color tweaking, noise reduction with certain plugins, adding labels, etc.). Converting a FITS to TIFF can be essentially lossless in terms of image data if done correctly. For example, if you have a 16-bit monochrome FITS, saving it as a 16-bit TIFF with no compression (or lossless compression) will keep the pixel values the same. The image will look identical - a TIFF can store that image just fine. The differences come in with metadata and certain format limits. A TIFF doesn't inherently know about all the FITS-specific header info. It has its own system of tags for metadata (like EXIF tags, primarily used by cameras). You won't find a standard tag in TIFF for “telescope RA coordinate” or “airmass” or things like that. So when you convert to TIFF, you usually lose the rich astronomy metadata. If all you care about is the pretty picture at that point, that might be fine. But it's one reason to keep the FITS - that's the copy which still remembers everything about how the image was taken.
Another potential issue: some software might automatically apply a stretch or color balance when converting FITS to TIFF, if not careful. Tools like the FITS Liberator (made by ESA/ESO/NASA) explicitly let you choose a stretch to apply when exporting to TIFF, since a linear TIFF opened in Photoshop would look black otherwise. If you do apply such a stretch and save, that TIFF is no longer raw; it's a “baked” version optimized for viewing. That's fine for final output, but you definitely wouldn't want to then use that stretched TIFF to do scientific measurements or further heavy processing - you've essentially made it like a high-quality JPEG at that point (with more bit depth, hopefully, but still a processed image). So best practice: do your calibration, stacking, and initial stretching on the FITS data. If you want to migrate to another software that doesn't read FITS, convert to a 16-bit TIFF after you've gotten the image mostly in shape (e.g., stretched, color combined). And again, keep the original FITS somewhere safe, so you can always revisit it.
Now, XISF - which stands for eXtensible Image Serialization Format. This is a relatively new kid on the block, introduced by the makers of PixInsight (a very popular astrophotography processing software). PixInsight's developers created XISF to address what they saw as limitations of FITS. They argue that FITS is old, limited, and sometimes ambiguous or inconsistent across implementations. XISF is designed to be more modern: it's built on XML, supports hierarchical data, can include multiple images and data structures in one file, and allows compression and inclusion of processing history or other complex metadata. Essentially, XISF is PixInsight's attempt at a next-generation astro format.
If you convert a FITS to XISF, or if your capture software directly saves XISF, what happens? In terms of raw image data, XISF will store the same numbers just as accurately. There's no loss of quality - it can even be better in some ways because XISF can compress the data without losing information (e.g., using a lossless compression like LZ4 or similar, automatically, so files take less space). XISF also doesn't have the 80-character card limitation for metadata, so it can store more verbose information or even binary large objects as metadata. For example, PixInsight might embed the entire provenance of an image (what processes you applied to it) in an XISF as a history log, something FITS can't really do.
However, the trade-off is compatibility. FITS is universally recognized; XISF, as of now, is mostly limited to PixInsight and a few tools that have added support for it. If you try to open an XISF in a non-PixInsight program, chances are it won't know what to do with it. That's why some astrophotographers stick to FITS even when using PixInsight - especially if they plan to use multiple software packages in their workflow or share the data with others who may not use PixInsight. On the other hand, if you are all-in on PixInsight, using XISF as your working format can be convenient. For instance, PixInsight's weighted batch preprocessing script allows saving integrated images as XISF with compression, which can save disk space (those integrated masters can be huge!). XISF also avoids some quirkiness of FITS (like having to pad headers to multiples of 2880 bytes - an old requirement - which wastes a bit of space, or potential confusion about data types and endian-ness which XISF handles in a self-describing way).
So, converting FITS to XISF is largely a wash in terms of data integrity (no loss), and might gain you smaller files or richer metadata, but you lose universality. Think of XISF as a specialized container for those deep into one ecosystem. It's similar to how Adobe has PSD for Photoshop - great if you stay in Photoshop, not so useful elsewhere.
The key advice I give to everyone is: never delete or overwrite your original FITS files after converting to something else. Storage is cheap compared to the nights of effort it took to gather that data. If you convert to TIFF for final edits, save those TIFFs separately and archive your FITs. If you decide to use XISF for a project, that's fine - but I would still keep the initial captures in FITS (or at least export to FITS at the end) in case one day you want to open them in a different program or the XISF format ever becomes unsupported (unlikely in the near term, but one never knows decades down the road).
Finally, it's worth noting that converting formats should ideally be done when absolutely needed, and as infrequently as possible. Each conversion is a chance to accidentally clip or truncate something (for example, converting a 32-bit float FITS to a 16-bit TIFF - you have to scale it properly or you might cut off values above 65535 or lose precision). If you stay in FITS throughout your main workflow, you eliminate these worries. Then do a controlled export for specific purposes (like making a print, sharing online, etc.).
In short, TIFF is great for compatibility with mainstream image editors and for producing deliverables, and XISF is great within PixInsight's realm for enhanced capability. Both can co-exist with FITS in your toolbox. But neither TIFF nor XISF should be seen as a reason to discard the original FITS. Think of FITS as your digital negative; TIFF as perhaps the print you hang on the wall; and XISF as a fancy storage box you might use within one lab. The negative stays in the archive, because you can always make new prints from it.
All this talk about the greatness of FITS - but how do you actually look at and process these files? It's true that if you double-click a FITS file on a typical computer, nothing might happen (unless you've installed specific software). Regular image viewers won't know what a .fit or .fits file is. That's because, as we've emphasized, FITS is a scienceformat, not a consumer photo format. But fear not - there are plenty of tools available, many of them free.
For someone starting out in astrophotography, a common path is to use a stacking software like DeepSkyStacker (for Windows) or Siril (Windows/Mac/Linux) to calibrate and combine their raw images. These programs natively read FITS files (and can also ingest DSLR RAW files, converting them under the hood to FITS or similar for processing). So the first place you might “open” a FITS is in one of these stacking programs. After stacking, you'll likely save the result as a FITS again for further processing.
When it comes to processing (stretching, color adjustment, noise reduction, etc.), there are powerful astro-focused tools like PixInsight (which we've mentioned a lot), Astro Pixel Processor, and others. PixInsight can read and write FITS seamlessly (as well as its own XISF). It's a paid software, but extremely popular among serious astrophotographers. Astro Pixel Processor is another paid tool focusing on stacking and initial processing, which also works with FITS. If you prefer something free and open-source, Siril has become quite capable - it's a bit like having some PixInsight-like functionalities for free, and it's designed to work with FITS (in fact, Siril's native format is also FITS, and it uses .fitextension by default).
But maybe you're not ready to dive into specialized astro software and you just want to view a FITS image to see what's in it. For that, you have options like FITS Liberator - a free tool provided by ESA/ESO/NASA. FITS Liberator allows you to open a FITS, play with stretches (it gives you sliders for black level, white level, and some non-linear scaling functions), and then output a TIFF or JPEG. It's geared a bit towards people processing Hubble data for outreach, but anyone can use it to inspect and convert astro files. Another viewer is SAOImage DS9 (often just called DS9). This is more of a professional astronomy tool, originally from the Smithsonian Astrophysical Observatory, used to view FITS images with multiple frames, do blink comparisons, analyze pixel values, etc. It's overkill if you just want to look, but it's very powerful if you ever need it (and it's free).
For Mac users, there's a handy quick-look plugin called FITS Preview (by CloudMakers) that lets you see a thumbnail of a FITS in Finder as you would with a normal image, and open it to see a stretched version quickly. On Windows, some people use the viewer in software like APT (Astro Photography Tool) or NINA (Nighttime Imaging 'N' Astronomy) which are capture programs but have image viewer modules. There are also Photoshop plugins that historically allowed opening FITS directly in Photoshop (one such plugin was distributed with an older version of FITS Liberator, effectively to integrate into Photoshop). However, I find that with the specialized astro tools available, using Photoshop directly on a raw FITS is less common these days - typically we'd convert to TIFF once we reach that stage.
If you're a bit of a techie or programmer, you'll be interested to know that FITS has libraries in many languages (C, Python, Java, etc.). The Python Astropy library has an astropy.io.fits module that makes it easy to load a FITS file into an array, manipulate it, and read the header. This is more for those doing custom analysis, but I mention it to illustrate that FITS is so standard that robust libraries exist to handle it behind the scenes of many applications. In fact, most astro programs are using one of these libraries under the hood when you open a file - you just interact with the friendly GUI on top.
For a beginner who just wants to see their images: I'd recommend FITS Liberator or Siril (Siril has a viewer where you can open images and stretch them interactively). These are straightforward to install and use. As you progress, you might invest in PixInsight, which then becomes your one-stop environment for handling FITS (and converting to XISF or TIFF as needed).
I also want to highlight a simple but powerful trick: because the FITS header is text, you can actually read a lot of useful info without any special software. If you're on Linux or macOS, you can use the strings command or a text editor (just be careful not to alter anything) to scroll through the first part of the file and see the header entries. On Windows, even Notepad might display some of it (though the binary data afterwards will show up as gibberish). This can be handy if, say, you want to quickly confirm which filter was used or the exact center coordinates of an image without fully opening it in a heavy program. Of course, dedicated FITS viewers will show you the header in a nice formatted way too (most have an option to view header or metadata).
In summary, working with FITS files does require using astronomy-specific software tools - but the good news is there's a whole ecosystem of those tools, many of them free. Once you have your toolkit set up, opening a FITS becomes as routine as opening a JPEG in an image viewer, albeit with the extra step that you might adjust a stretch to actually see the content properly. And mastering these tools is part of the fun of astrophotography: you gain not only pretty pictures but also insight into the data behind them. It's a skill set that connects you to how professional astronomers handle imagery. The learning curve may be a bit steeper than using basic photo apps, but the reward is the ability to truly dig into your celestial captures.
With how long FITS has been around (we're talking 40+ years now), a reasonable question to ask is: will something newer and better come along to replace it? In tech, four decades is an eternity - most computer formats don't last that long without becoming obsolete. Yet FITS is still here, actively used and maintained. The honest answer is that there are efforts to introduce new formats, but FITS is so deeply entrenched and well-proven that any replacement has a high bar to clear.
We already discussed XISF, the format created by PixInsight's team. PixInsight's developers have been quite vocal in calling FITS “obsolete” or “too limited” for modern use, citing issues like the rigid header structure, lack of support for complex data relationships, and so on. In PixInsight's ecosystem, they indeed prefer users to adopt XISF for saving work. Over time, if more software outside PixInsight starts supporting XISF, it could gain traction. However, at this moment XISF is not an IAU or NASA standard - it's more of a community-driven solution targeted at astrophotographers specifically. Professional observatories are not yet saving their raw data in XISF (they'd have to rewrite a lot of pipelines to do that). It's possible that down the line, if XISF (or any new format) demonstrates clear superiority and enough tools support it, we could see a shift. But transitions in science happen slowly. Remember, one of FITS's strengths is backward compatibility - a new format would have to convince people that the benefits outweigh the cost of changing decades of habits and software.
There are other formats in the scientific world too. For instance, some large projects dealing with terabytes of data have looked into using HDF5 (a very general scientific data format) because it's good for huge multi-dimensional datasets. Occasionally you'll hear about missions exporting data in HDF5 or NetCDF or other specialized formats. But for images, especially in astronomy, FITS has remained dominant.
It's also worth noting that the FITS standard itself has evolved. If some feature is needed, the community can (and has) added it via conventions or extensions. A good example is the World Coordinate System (WCS) conventions that were added to FITS to describe how a pixel coordinate maps to a position on the sky (with distortions, projection, etc.). This wasn't part of the original 1980s design, but rather than making a whole new format, astronomers defined standard header keywords and math for WCS and included it in FITS. Another example: compression. There's a FITS convention for storing a compressed image within a FITS file (called tile-compressed FITS). Software can implement that and then you have smaller files but still conform to FITS standard when uncompressed. So FITS has shown an ability to adapt within its framework.
In plain terms, will you ever use something else? If you stick exclusively to PixInsight, you might end up using XISF a lot. But even then, if you collaborate with others or publish data, you'll likely still revert to FITS for sharing. Many astrophotographers actually save in both: they keep FITS masters for archival and share those if needed, but do their intermediate work in XISF to take advantage of smaller file sizes and extra features. That approach covers both bases.
Looking at the future, I suspect FITS will still be around for a long time. It's like the trusty old workhorse that might not be glamorous but gets the job done consistently. Even if something technically “better” exists, the inertia of an entire field using FITS is enormous. That said, the next generation of astronomers might eventually decide on a new standard if data demands change drastically (for instance, if we had to handle petabyte-scale images routinely, or highly complex interconnected datasets, a new paradigm might be needed). But any such future format would likely provide converters from legacy FITS, ensuring that all the archival data isn't lost.
For you as an astrophotographer now, the takeaway is: learn FITS, and don't worry too much about it going away. It's far more likely you'll still be using it 10 or 20 years from now than not. And if it does evolve, the knowledge you gained (about things like linear data, metadata, calibration, etc.) will directly transfer to whatever new format comes along. After all, the core principles of capturing and preserving photons won't change, just the container might.
In conclusion, a FITS astrophotography file is the definitive record of your night sky adventures. It's the format that contains everything - from the raw starlight to the context of how you captured it. We've seen where it came from, why it was invented, and why it's become the backbone of astro-imaging for both amateurs and professionals. We've looked at what's inside (headers and data), discussed how it compares to other formats, and explored how to use it effectively. By embracing FITS, you're not just hopping on a bandwagon; you're empowering yourself with the full fidelity of your data. It might feel a bit technical at first, but it becomes second nature, and the payoff in image quality and insight is tremendous.
I often tell newcomers: once you truly grasp what a FITS file offers and you process your images with it, you won't want to go back to the old ways. I wasn't exaggerating that at the start - I genuinely shoot everything in FITS or RAW, and I haven't used an in-camera JPEG for deep-sky imaging in ages. Why would I? I'd be throwing away hard-earned signal. After reading all this, I hope you feel the same way - that you're excited to work with the “pure oil” of the imaging data rather than the diluted stuff. Your future self (perhaps reprocessing your data on a rainy day with new techniques) will thank you for keeping those high-quality files safe. Clear skies, and happy imaging - may your hard drives be full of FITS and your processed images full of wonder!
Address:
1855 S Ingram Mill Rd
STE# 201
Springfield, Mo 65804
Phone: 1-844-277-3386
Fax: 417-429-2935
E-Mail: hello@scopetrader.com