tree cc6b7c40c3a16a360fdd2dc710a068439bfd71f5
parent ab95eb709f42d5dabcda86b31d35429f25a4934b
author Linus Torvalds <Linus.Torvalds@helsinki.fi> 763649476 +0000
committer Nicolas Pitre <nico@cam.org> 1187547576 -0400

Linux 1.0---A better UNIX than Windows NT

Summary: Linux 1.0 released
Keywords: Linux Kernel 1.0 Academy Awards
X-Moderator-Added-Keywords: universe, end of

Finally, here it is.  Almost on time (being just two years late is
peanuts in the OS industry), and better than ever:

	Linux kernel release 1.0

This release has no new major features compared to the pl15 kernels, but
contains lots and lots of bugfixes: all the major ones are gone, the
smaller ones are hidden better.  Hopefully there are no major new ones.

The Linux kernel can be found as source on most of the Linux ftp-sites
under the names

	linux-1.0.tar.gz		(full source)
	linux-1.0.patch.pl15.gz		(patch against linux-0.99pl15)
	linux-1.0.patch.alpha.gz	(patch from linux-pre-1.0)

it should be available at least at the sites

	ftp.funet.fi:
		pub/OS/Linux/PEOPLE/Linus	(now)
	sunsite.unc.ed:
		pub/Linux/Incoming		(now)
		pub/Linux/kernel		(soon)
	tsx-11.mit.edu:
		pub/linux/sources/system	(soon)
	ftp.cs.helsinki.fi:
		pub/Software/Linux/Kernel	(now)

This release finally moves Linux out of Beta status and is meant as a
base for distributions to build on.  It will neither change Linux'
status as FreeWare under the GPL, nor will it mean the end of
development on Linux.  In fact many new features where held back for
later releases so that 1.0 could become a well tested and hopefully
stable release.

The Linux kernel wouldn't be where it is today without the help of lots
of people: the kernel developers, the people who did user-level programs
making linux useful, and the brave and foolhardy people who risked their
harddisks and sanity to test it all out.  My thanks to you all.
(Editorial note: if you think this sounds too much like the Academy
Awards ceremony, just skip this: it's not getting any better.)

Thanks to people like Aaron Kushner, Danny ter Haar and the authors of
the AnwenderHandbuch (and others) who have helped me with hardware or
monetary donations (and to the Oxford Beer Trolls and others who took
care of the drinkware).  And thanks to Dirk, who helped me write this
announcement despite my lazyness ("hey, it's just another release, who
needs an announcement anyway?").

To make a long and boring story a bit shorter and boring, here is at
least a partial list of people who have been helping make Linux what it
is today.  Thanks to you all,

	Krishna Balasubramanian <balasub@cis.ohio-state.edu>
	Arindam Banerji <axb@cse.nd.edu>
	Peter Bauer <100136.3530@compuserve.com>
	Fred Baumgarten <dc6iq@insu1.etec.uni-karlsruhe.de>
	Donald Becker <becker@super.org>
	Stephen R. van den Berg <berg@pool.informatik.rwth-aachen.de>
	Hennus Bergman <hennus@sky.nl.mugnet.org>
	Ross Biro <bir7@leland.Stanford.Edu>
	Bill Bogstad <bogstad@cs.jhu.edu>
	John Boyd <boyd@cis.ohio-state.edu>
	Andries Brouwer <aeb@cwi.nl>
	Remy Card <Remy.Card@masi.ibp.fr>
	Ed Carp <ecarp@netcom.com>
	Raymond Chen <raymondc@microsoft.com>
	Alan Cox <iiitac@pyr.swan.ac.uk>
	Laurence Culhane <loz@holmes.demon.co.uk>
	Wayne Davison <davison@borland.com>
	Thomas Dunbar <tdunbar@vtaix.cc.vt.edu>
	Torsten Duwe <Torsten.Duwe@informatik.uni-erlangen.de>
	Drew Eckhardt <drew@cs.Colorado.EDU>
	Bjorn Ekwall <bj0rn@blox.se>
	Doug Evans <dje@cygnus.com>
	Rik Faith <faith@cs.unc.edu>
	Juergen Fischer <fischer@server.et-inf.fho-emden.de>
	Jeremy Fitzhardinge <jeremy@sw.oz.au>
	Ralf Flaxa <rfflaxa@immd4.informatik.uni-erlangen.de>
	Nigel Gamble <nigel%gamble.uucp@gate.net>
	Philip Gladstone <philipg@onsett.com>
	Bruno Haible <haible@ma2s2.mathematik.uni-karlsruhe.de>
	Andrew Haylett <ajh@gec-mrc.co.uk>
	Dirk Hohndel <hohndel@informatik.uni-wuerzburg.de>
	Nick Holloway <alfie@dcs.warwick.ac.uk>
	Ron Holt <ron@novell.com>
	Rob W. W. Hooft <hooft@EMBL-Heidelberg.DE>
	Michael K. Johnson <johnsonm@sunsite.unc.edu>
	Fred N. van Kempen <waltje@uwalt.nl.mugnet.org>
	Olaf Kirch <okir@monad.swb.de>
	Ian Kluft <ikluft@thunder.sbay.org>
	Rudolf Koenig <rfkoenig@immd4.informatik.uni-erlangen.de>
	Bas Laarhoven <bas@vimec.nl>
	Warner Losh <imp@boulder.parcplace.com>
	H.J. Lu <hjl@nynexst.com>
	Tuomas J. Lukka <Tuomas.Lukka@Helsinki.FI>
	Kai M"akisara <Kai.Makisara@vtt.fi>
	Pat Mackinlay <pat@it.com.au>
	John A. Martin <jmartin@csc.com>
	Bradley McLean <brad@bradpc.gaylord.com>
	Craig Metz <cmetz@tjhsst.edu>
	William (Bill) Metzenthen <billm@vaxc.cc.monash.edu.au>
	Rick Miller <rick@discus.mil.wi.us>
	Corey Minyard <minyard@wf-rch.cirr.com>
	Eberhard Moenkeberg <emoenke@gwdg.de>
	Ian A. Murdock <imurdock@shell.portal.com>
	Johan Myreen <jem@vipunen.hut.fi>
	Stefan Probst <snprobst@immd4.informatik.uni-erlangen.de>
	Daniel Quinlan <quinlan@bucknell.edu>
	Florian La Roche <rzsfl@rz.uni-sb.de>
	Robert Sanders <gt8134b@prism.gatech.edu>
	Peter De Schrijver <stud11@cc4.kuleuven.ac.be>
	Darren Senn <sinster@scintilla.santa-clara.ca.us>
	Chris Smith <csmith@convex.com>
	Drew Sullivan <drew@lethe.north.net>
	Tommy Thorn <Tommy.Thorn@daimi.aau.dk>
	Jon Tombs <jon@gtex02.us.es>
	Theodore Ts'o <tytso@mit.edu>
	Simmule Turner <simmy@digex.com>
	Stephen Tweedie <sct@dcs.ed.ac.uk>
	Thomas Uhl <uhl@sun1.rz.fh-heilbronn.de>
	Juergen Weigert <jnweiger@immd4.informatik.uni-erlangen.de>
	Matt Welsh <mdw@sunsite.unc.edu>
	Marco van Wieringen <mvw@mercury.mcs.nl.mugnet.org>
	Stephen D. Williams <sdw@lig.net>
	G\"unter Windau <gunter@mbfys.kun.nl>
	Lars Wirzenius <lars.wirzenius@helsinki.fi>
	Roger E. Wolff <wolff@dutecai.et.tudelft.nl>
	Frank Xia <qx@math.columbia.edu>
	Eric Youngdale <eric@tantalus.nrl.navy.mil>
	Orest Zborowski <orestz@microsoft.com>

A more detailed list with contact and description information can be
found in the CREDITS file that accompanies the kernel sources.
