Some links on this page are affiliate links: if you buy through them we may earn a commission, at no extra cost to you.
Atmel and Microchip were once separate semiconductor companies with overlapping audiences, especially among engineers, embedded developers, hobbyists, and Arduino users. Atmel became widely known for AVR microcontrollers, the ATmega328P at the heart of classic Arduino boards, and its ARM-based SAM devices. Microchip, meanwhile, built a long-running ecosystem around PIC microcontrollers, development tools, and broad embedded support.
In 2016, Microchip acquired Atmel, bringing AVR, SAM, touch, security, memory, and wireless product lines under the Microchip umbrella. The Atmel name largely disappeared as a standalone brand, but many of its parts did not; they were folded into Microchip’s catalog, documentation systems, supply chain, and development tool strategy.
As an Amazon Associate I earn from qualifying purchases.
For developers, the practical question is not whether Atmel still exists as an independent company, but how its former products fit into Microchip’s current roadmap. AVR and SAM devices remain relevant, but choosing parts today means understanding Microchip’s tooling, availability signals, product lifecycle status, and how legacy Atmel ecosystems map to modern Microchip support.
Atmel Before the Acquisition
Before it became part of Microchip, Atmel was an independent semiconductor company best known for microcontrollers, nonvolatile memory, touch-sensing technology, and secure embedded products. Founded in 1984, Atmel built a broad catalog that served hobbyists, industrial engineers, automotive designers, consumer electronics companies, and embedded product teams. Its public identity eventually became closely tied to AVR microcontrollers, but the company’s portfolio was much wider than the chips found on Arduino boards.
Popular on Amazon
The AVR family was Atmel’s most recognizable success. Introduced in the 1990s, AVR was an 8-bit RISC microcontroller architecture with on-chip flash memory, simple peripherals, low-cost development options, and a clean programming model. Parts such as the ATmega8, ATmega168, ATmega328, ATmega32U4, and ATtiny85 became staples in education, prototyping, small appliances, lighting controls, toys, instrumentation, and maker projects. The ATmega328P, used on the Arduino Uno, gave Atmel enormous visibility outside traditional embedded engineering circles.
Atmel also invested heavily in 32-bit microcontrollers. Its SAM product lines used Arm cores, including Cortex-M0+, Cortex-M3, Cortex-M4, and later Cortex-M7 devices. Families such as SAM D, SAM L, SAM C, SAM E, SAM G, SAM S, and SAM V targeted applications ranging from low-power sensors to motor control, automotive interfaces, industrial control, and audio. These devices competed directly with Arm-based microcontrollers from STMicroelectronics, NXP, Texas Instruments, and Microchip itself.
The Tool Desk
Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Major Atmel product areas before the deal
- AVR 8-bit MCUs: ATmega and ATtiny devices used in embedded control, Arduino-compatible boards, and low-cost products.
- AVR 32-bit MCUs: A separate 32-bit AVR architecture, including AVR32 UC3 devices, aimed at higher-performance embedded applications.
- SAM Arm MCUs: Cortex-M based microcontrollers for modern 32-bit embedded designs.
- maXTouch: Capacitive touch controllers used in phones, tablets, appliances, automotive panels, and industrial interfaces.
- CryptoAuthentication and security ICs: Devices for authentication, key storage, and hardware-assisted security.
- EEPROM and flash memory: Serial memory products used alongside microcontrollers in embedded systems.
Atmel’s development ecosystem was centered on tools such as AVR Studio, later renamed Atmel Studio, along with GCC-based compilers, device packs, programmers, debuggers, and evaluation boards. The AVRISP, JTAGICE, AVR Dragon, Atmel-ICE, Xplained boards, and Xplained Pro boards gave developers relatively affordable ways to program and debug devices. Atmel was also friendly to open-source compiler workflows, especially through avr-gcc and avrdude, which helped AVR become common in classrooms and community projects.
By the time Microchip entered the picture, Atmel had strong technology and recognizable brands, but it was competing in crowded markets. AVR faced pressure from cheap Arm Cortex-M0 and Cortex-M0+ parts, while SAM competed against large vendors with deep software libraries and broad distribution. Atmel still had valuable assets: a loyal AVR user base, solid Arm microcontrollers, widely used touch technology, security chips, memory products, and design wins across industrial and consumer markets. That mix made the company an attractive acquisition target rather than just another microcontroller vendor.
Why Microchip Bought Atmel
Microchip announced its agreement to acquire Atmel in January 2016, in a deal valued at about $3.56 billion. The move was not just about buying a competitor; it was about filling gaps in Microchip’s portfolio and gaining access to product families, customers, and engineering assets that Microchip did not fully have on its own. Before the acquisition, Microchip was best known for PIC microcontrollers, analog parts, memory, power management, and embedded connectivity. Atmel brought a large installed base around AVR, strong ARM-based SAM microcontrollers, capacitive touch technology, secure authentication devices, and a deep presence in maker, education, industrial, automotive, and consumer electronics markets.
One major attraction was Atmel’s microcontroller lineup. Microchip already had an enormous 8-bit business with PIC10, PIC12, PIC16, and PIC18 devices, plus 16-bit and 32-bit PIC families. Atmel added AVR, one of the most recognizable 8-bit architectures in embedded development. AVR had become especially visible through Arduino, but its use extended far beyond hobby boards into appliances, battery-powered products, motor control, lighting, industrial controls, and user-interface electronics. By acquiring Atmel, Microchip gained both the AVR silicon business and the loyalty of developers who preferred AVR’s instruction set, peripherals, toolchains, and established code base.
Windows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallCrashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minuteAtmel’s ARM Cortex-M portfolio also mattered. The SAM D, SAM C, SAM E, SAM L, SAM G, and SAM V families gave Microchip a broader 32-bit microcontroller offering, especially in low-power, USB, automotive, industrial, and connectivity-oriented designs. While Microchip had its own 32-bit PIC32 line based on MIPS at the time, Atmel’s SAM devices gave it an immediate, mature ARM Cortex-M catalog. That strengthened Microchip’s position with engineers and companies standardizing on ARM, a trend that had become difficult for any major microcontroller vendor to ignore.
Also popular on Amazon
The acquisition also expanded Microchip outside the core MCU socket. Atmel had valuable technology in touch sensing, especially QTouch and capacitive button, slider, and wheel interfaces. It also had secure element and authentication products, wireless devices, EEPROM and memory products, and automotive-qualified components. These fit well with Microchip’s strategy of selling complete embedded solutions rather than only the main controller. A design might use a microcontroller, touch controller, secure authentication chip, EEPROM, voltage regulator, clock source, and interface device; owning more of those blocks increased Microchip’s opportunity to win more content on each board.
Business drivers behind the deal
- Broader microcontroller coverage: Microchip gained AVR and SAM alongside PIC, giving customers more architecture choices.
- Access to ARM Cortex-M designs: Atmel’s SAM line helped Microchip compete in markets where ARM was the preferred platform.
- Developer community reach: AVR’s connection to Arduino, education, and open-source projects gave Microchip a larger audience of engineers and future professionals.
- More attach products: Touch, security, memory, wireless, and analog devices complemented Microchip’s existing catalog.
- Scale and distribution: Combining sales channels, manufacturing planning, and support networks helped Microchip serve larger customers and more regions.
For developers, the practical meaning was that Atmel did not disappear as a technology base, but it did become part of Microchip’s product and support strategy. Microchip bought Atmel because those parts had real market demand, mature ecosystems, and long design lifetimes. The goal was not to replace AVR with PIC overnight or to shut down SAM in favor of PIC32; it was to own a wider set of embedded platforms and keep serving customers already invested in them. That context helps explain many former Atmel devices are still sold today under Microchip, often with updated documentation, revised ordering pages, and support through Microchip’s tools and distribution channels.
What Happened to AVR, SAM, and Other Atmel Product Lines
After Microchip completed its acquisition of Atmel in 2016, Atmel’s major product families did not disappear. Instead, they were folded into Microchip’s catalog and gradually rebranded, renumbered in some documentation, and supported through Microchip’s sales, distribution, and development-tool channels. For developers, the practical result was continuity rather than a hard reset: AVR parts remained AVR parts, SAM microcontrollers remained Arm-based SAM devices, and many familiar development boards, datasheets, and application s stayed available, even if the logos and download locations changed.
Do these 3 things before closing this tab:
1Scan for outdated or missing drivers - takes under a minute2Clear out junk files and repair common Windows errors3Fix the driver behind crashes, sound loss and screen glitchesThe most visible survivor was the AVR family, including classic 8-bit devices such as the ATmega328P, ATmega32U4, ATtiny85, and many ATxmega parts. These chips retained their architectural identity: AVR instruction set, familiar peripherals, fuse configuration, ISP programming, and broad compiler support. Microchip later expanded the line with newer tinyAVR, megaAVR 0-series, AVR DA, AVR DB, and AVR DD devices. These newer AVRs kept the low-cost 8-bit focus but added more modern peripherals, event systems, configurable , better analog blocks, and in some cases higher memory densities than many older Atmel-era parts.
The SAM product families also continued under Microchip. These are Arm Cortex-M microcontrollers that Atmel had built for developers needing more performance, memory, connectivity, or peripheral bandwidth than 8-bit AVR could reasonably provide. Families such as SAM D, SAM L, SAM C, SAM E, SAM G, and SAM V remained part of the portfolio, serving roles from low-power USB devices to automotive, industrial, motor-control, and higher-performance embedded applications. The Arduino Zero and many Adafruit, SparkFun, and Seeed boards helped make SAM D21 especially recognizable among hobbyist and professional developers.
Where the main Atmel families ended up
| Atmel-era family | What happened after the acquisition | Typical use today |
|---|---|---|
| AVR 8-bit MCUs | Kept, supported, and expanded with newer AVR generations | Simple control, Arduino-compatible designs, low-cost embedded products |
| SAM Arm MCUs | Kept as Microchip SAM devices within the 32-bit MCU portfolio | USB, motor control, low power, industrial, connected embedded systems |
| ATtiny and ATmega | Continued, with both legacy and newer pin/peripheral variants | Small controllers, legacy boards, simple sensor and actuator nodes |
| ATxmega | Maintained for existing designs, but less central than newer AVR and SAM lines | Legacy products and designs needing XMEGA-specific peripherals |
| CryptoAuthentication and security ICs | Integrated into Microchip’s security portfolio | Secure authentication, key storage, IoT device identity |
Some Atmel lines became more strategic than others. AVR and SAM received the clearest long-term homes because they fit neatly into Microchip’s MCU structure: AVR for 8-bit designs, SAM for Arm-based 32-bit designs, and PIC alongside AVR as Microchip’s other major 8-bit architecture. Other products, such as memory, touch controllers, wireless devices, and security chips, were absorbed into existing Microchip business units. In many cases the silicon stayed the same while the ordering pages, parametric search tools, and support contacts moved to Microchip’s website.
Developers maintaining older Atmel designs generally did not need to redesign solely because of the acquisition. A board using an ATmega328P, ATtiny1616, ATSAMD21, or ATSAME70 still targets the same electrical characteristics and programming model described in its datasheet. The bigger changes were organizational: Microchip part pages became the source of current documentation, Microchip Direct became a primary purchasing route, and newer design recommendations increasingly pointed toward current AVR and SAM families rather than older Atmel-era devices nearing a mature or legacy status.
Free tools Windows power users keep installed
One-click scans. No signup required.
Also popular on Amazon
For new designs, the lesson is to treat “Atmel” as historical branding and “Microchip” as the current supplier. If a design depends on Arduino compatibility, tiny firmware, ultra-low bill of materials, or long-lived 8-bit simplicity, AVR remains a valid choice. If it needs more RAM, DMA, USB, CAN, Ethernet, advanced timers, or higher clock speeds, SAM devices are usually the more natural continuation of Atmel’s 32-bit roadmap under Microchip.
How Development Tools and Ecosystems Changed
After the acquisition, the most visible change for developers was not that AVR or SAM programming suddenly stopped working, but that Atmel’s tools were gradually folded into Microchip’s broader ecosystem. Atmel Studio, the Windows IDE long used for AVR and SAM development, continued to exist for a while as the familiar option for existing projects. Over time, Microchip steered new development toward MPLAB X IDE, MPLAB XC compilers, MPLAB Code Configurator, and the Microchip Packs framework. This put former Atmel devices alongside PIC, dsPIC, and other Microchip families inside one vendor toolchain.
For AVR users, the transition was mixed but generally manageable. Classic workflows based on avr-gcc, avr-libc, avrdude, Atmel-ICE, and Arduino remained widely used. Microchip did not remove the open-source AVR toolchain from the landscape, and many developers still build production firmware with Make, CMake, PlatformIO, or Arduino CLI rather than a vendor IDE. The main difference is that official device packs, datasheets, application s, and programming tools now come from Microchip’s website and documentation systems instead of Atmel’s old portals.
SAM developers saw a bigger ecosystem shift because these Arm Cortex-M parts were more closely tied to vendor software frameworks. Atmel Software Framework, commonly called ASF, was historically the standard starting point for many SAM projects. Microchip later emphasized newer configuration and middleware paths, including MPLAB Harmony for many 32-bit devices and MCC support where available. Some older SAM designs still depend on ASF examples, board support packages, and startup code, so maintaining legacy projects may mean keeping a known-good version of Atmel Studio, ASF, or a checked-in copy of generated code.
Common toolchain changes developers encountered
- IDE migration: Atmel Studio remained useful for existing AVR and SAM projects, while MPLAB X became Microchip’s main cross-family IDE.
- Compiler alignment: AVR development still relies heavily on GCC-based tools, while Microchip’s XC compilers and device packs became more prominent in official examples.
- Configurator changes: ASF-era examples gave way in many cases to MPLAB Code Configurator or Harmony-style project generation.
- Programmer support: Tools such as Atmel-ICE continued to be relevant, while Microchip programmers and debuggers gained support for former Atmel devices.
- Documentation location: application notes, errata, pack files, and product pages moved under Microchip branding and part-number search systems.
The Arduino ecosystem softened the impact for many AVR developers. Boards based on ATmega328P, ATmega32U4, ATmega2560, and related chips continued to be supported by Arduino cores, third-party board packages, and a large base of libraries. In that world, the Atmel-to-Microchip change mostly affected supply chain labels, datasheet links, and programmer drivers rather than day-to-day coding. A developer blinking LEDs or shipping a small AVR-based product may never need to open MPLAB X at all.
For professional teams, the practical approach is to separate source stability from vendor-tool churn. Keep compiler versions, device packs, linker scripts, startup files, generated peripheral code, and programming scripts under version control or in a reproducible build environment. If a project was created in Atmel Studio with ASF, do not assume a clean import into newer Microchip tools will be frictionless. For new designs, check whether the target AVR or SAM device has first-class support in the current Microchip tools, whether examples match the exact peripheral set, and whether the debugger you plan to use supports the package and programming interface. The parts survived the acquisition, but the most reliable development experience comes from choosing a toolchain deliberately rather than assuming the old Atmel workflow and the new Microchip workflow are identical.
Availability, Support, and Long-Term Product Strategy
After the acquisition, Microchip folded Atmel parts into its normal product lifecycle and supply-chain model. In practice, that meant AVR, SAM, ATtiny, ATmega, ATxmega, QTouch, CryptoAuthentication, and related families were listed through Microchip’s ordering systems, documentation portal, parametric search, sample program, and distributor channels. Many familiar Atmel part numbers stayed recognizable, so devices such as the ATmega328P, ATtiny85, ATSAMD21, and SAME70 did not suddenly become different chips. The label, packaging source, datasheet format, and ordering pages changed over time, but the silicon families remained part of Microchip’s catalog.
Also popular on Amazon
For developers, the biggest practical issue has been availability rather than ownership history. During broad semiconductor shortages, popular AVR and SAM devices saw the same lead-time pressure as many other microcontrollers. Arduino demand, industrial reuse of legacy AVR designs, and the popularity of SAMD21-based boards all contributed to uneven stock at times. Microchip generally kept these families active, but availability could vary sharply by package, temperature grade, flash size, and reel quantity. A design based on a common ATmega328P package might be easier to source than a less-used XMEGA variant, while a mainstream SAMD21 or SAM E5x part may have better forward momentum than an older niche device.
Microchip’s support approach tends to favor long product lifetimes, especially for embedded and industrial customers. That is good news for teams maintaining products with long field lives: many legacy Atmel devices remain orderable, documented, and supported through application s, errata, programming tools, and distributor inventory. Even so, “still available” is not the same as “best choice for a new design.” Some older devices are mature, have limited memory, lack modern security features, or are less attractive on price-per-feature than newer tinyAVR, megaAVR 0-series, AVR DA/DB, PIC, SAM D, SAM C, or SAM E devices.
How to judge a part for a new design
- Check lifecycle status: look for whether the device is listed as active, not recommended for new designs, mature, or end-of-life on Microchip’s product page.
- Check multiple packages: the same MCU may be easy to buy in QFN but scarce in TQFP, or available in industrial grade but not commercial grade.
- Compare family roadmaps: newer AVR and SAM families often have better peripheral sets, lower power modes, and stronger tool integration.
- Review programming support: confirm compatibility with MPLAB X, MPLAB Xpress, Microchip Studio, MPLAB Snap, PICkit, Atmel-ICE, or production programmers used by your manufacturer.
- Design for alternates: where possible, select pin-compatible or firmware-portable variants with different flash and RAM sizes.
For existing products, staying with an Atmel-origin part is often the lowest-risk path if the device is active and the supply outlook is acceptable. Firmware, validation data, bootloaders, board layouts, and regulatory approvals can make a migration more expensive than the MCU itself. In that case, the sensible strategy is to monitor Microchip’s product change notifications, buy through authorized distributors, keep a second-source assembly plan where possible, and periodically test builds with the latest compiler and device packs.
For new products, the decision should be based on current ecosystem fit rather than nostalgia for either logo. Classic AVR remains excellent for simple 8-bit control, education, hobby boards, and low-cost deterministic firmware. Newer AVR families make more sense when you want the same programming style with better peripherals. SAM parts are better suited for USB, higher performance, richer communications, motor control, capacitive touch, security, or RTOS-based designs. The acquisition did not erase Atmel’s technologies; it placed them inside Microchip’s larger catalog, where developers now need to choose by lifecycle status, supply confidence, tooling support, and long-term maintainability.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.What Developers Should Choose Today
For new designs, the practical choice is less about the old Atmel-versus-Microchip distinction and more about matching the device family to the job, the tooling you want to use, and the expected lifetime of the product. AVR, SAM, tinyAVR, megaAVR, AVR DA/DB, and other former Atmel lines are now Microchip product families, so developers should evaluate them alongside PIC, dsPIC, and Microchip’s broader analog, memory, and connectivity parts rather than treating them as separate ecosystems.
If you are building a simple control board, sensor node, user interface, small appliance controller, or education-focused project, AVR remains a very reasonable choice. Classic ATmega parts are familiar, widely documented, and strongly supported by Arduino-era examples, while newer tinyAVR and megaAVR 0-series/1-series devices add better peripherals, lower power modes, event systems, and improved pin flexibility. For many 8-bit applications, an AVR can still be cheaper, simpler, and easier to validate than moving to a 32-bit microcontroller.
For designs that need more memory, higher clock speeds, USB, advanced timers, capacitive touch, richer communications, or an RTOS, the SAM families are usually the better starting point. SAM D and SAM C devices fit many Cortex-M0+ embedded applications, while higher-end SAM E, SAM V, and SAM S parts suit motor control, industrial interfaces, audio, and more compute-heavy workloads. Developers already invested in ARM tooling may also prefer SAM parts because they fit naturally into CMSIS-based workflows and common debug probes.
Also popular on Amazon
Practical selection guidelines
- Choose classic AVR when you need maximum community examples, Arduino compatibility, simple firmware, or a low-risk replacement in an existing ATmega-based design.
- Choose newer AVR families when you want an 8-bit architecture but need modern peripherals, better power behavior, or longer forward-looking support from Microchip.
- Choose SAM Cortex-M devices when performance, memory size, DMA, USB, RTOS support, or advanced peripheral integration matters more than 8-bit simplicity.
- Consider PIC or dsPIC if Microchip’s application notes, reference designs, motor-control libraries, functional-safety material, or existing company experience point in that direction.
- Avoid choosing only by brand nostalgia; compare package availability, errata, tool support, pricing at your real volume, and second-source risk before committing.
For professional products, start every selection by checking Microchip’s current product status, recommended alternatives, data sheet revision history, errata, and inventory across authorized distributors. A microcontroller that is beloved in hobby circles may still be available, but that does not automatically make it the best choice for a product expected to ship for ten years. Conversely, an older AVR or SAM part may be the right answer if it is stable, well understood, already qualified, and available in the required package.
Tooling should also influence the decision. If your team uses Arduino, PlatformIO, avr-gcc, or a large base of existing AVR code, staying with AVR can save engineering time. If your workflow is built around MPLAB X, MPLAB XC compilers, Microchip debuggers, MCC-generated configuration, or ARM middleware, a newer AVR or SAM device may integrate more cleanly. The best choice today is the one that minimizes total project risk: enough performance headroom, dependable supply, clear support status, usable tools, and a migration path if the selected part becomes constrained.
Quick wins for a faster PC:
Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Repair Windows errors before they cause bigger problemsFix Now →Frequently Asked Questions
Does Atmel still exist as a separate company?
No. Microchip acquired Atmel in 2016, and Atmel no longer operates as an independent company. Its major product families, including AVR and SAM microcontrollers, were folded into Microchip’s catalog and are now sold, documented, and supported through Microchip channels.
Are AVR microcontrollers like the ATmega328P still being made?
Many classic AVR parts are still available, including devices used in Arduino-era designs, but availability varies by exact part number and package. Microchip has continued the AVR line and also introduced newer AVR families such as tinyAVR 0/1/2-series, megaAVR 0-series, and AVR DA/DB devices. For new designs, it is safer to check Microchip’s product status, stock across distributors, and recommended newer alternatives before committing.
What happened to Atmel Studio after the Microchip acquisition?
Atmel Studio was eventually rebranded and folded into Microchip Studio, while Microchip’s broader ecosystem continues to center on MPLAB X IDE, MPLAB XC compilers, and MPLAB-compatible tools. Older AVR and SAM projects may still build in Microchip Studio, but newer Microchip workflows increasingly point developers toward MPLAB X and vendor-supported configuration tools. If you are starting fresh, choose the toolchain that best matches the device family and support path Microchip currently recommends.
Should I choose AVR, SAM, or PIC for a new project today?
AVR is still a good fit for simple 8-bit embedded projects, educational hardware, Arduino-compatible designs, and low-cost control tasks. SAM devices are ARM Cortex-M parts and make more sense when you need higher performance, USB, richer peripherals, or a 32-bit software ecosystem. PIC and newer Microchip families may be better choices when Microchip’s current roadmap, peripheral set, pricing, or supply availability lines up better with your product requirements.
Recommended Free Tools
Will old Atmel documentation, programmers, and libraries still work?
In many cases, yes, especially for established AVR and SAM parts, but the support path has changed. Datasheets and application s are now hosted by Microchip, and some legacy libraries or examples have been replaced by newer Microchip frameworks and configuration tools. For production work, verify the latest datasheet revision, supported programmer/debugger list, compiler version, and errata before relying on older Atmel-era material.
Bottom Line
Atmel didn’t disappear so much as become part of Microchip, with AVR, SAM, tinyAVR, megaAVR, and related lines continuing under Microchip’s broader portfolio. For developers, that means the familiar chips are still widely used, but documentation, software, purchasing channels, and long-term support now live mostly in Microchip’s ecosystem.
If you’re starting a new design, choose parts based on current availability, lifecycle status, tool support, and whether AVR or SAM best fits your performance and power needs. For existing projects, keep an eye on Microchip product pages, migration s, and supported toolchains so you can maintain today’s hardware while planning sensible alternatives if supply or lifecycle changes arise.
