OSDev.org

I use:
Editor: Notepad++
Shell: cygwin (full install, took 6gb hd and 6 hours to install, but already had it long before i started my os) (bash)
Compiler: gcc-linux cross compiler (for cygwin)
Initrd: tar (the kernel uses tar archieve as initrd) (cygwin)
Emulator: bochs (windows)
Make: gnu make (cygwin)
Bootloader: isolinux (very easy to create very complex bootscreens with) (used mboot.c32 to load/exec the kernel)
Asm: nasm (cygwin)
Kernel format: elf
Browser: firefox
Host os: windows xp sp3
Host mem: 1024 mb
Host cpu: intel pentium 4 (32bit)
And a few basic shell utils (cp, rm, etc) and cdrtools (cygwin) to create iso with.

Executable drivers/user programs for my os are created this way:
gcc-linux -c <file.c(pp)> -o <file>
note that i don't link, the kernel does that.

Editor: MSVC++ 2008 Express (set up to invoke Cygwin make for compiling and testing)
Shell: Cygwin bash
Compiler: i686-elf-gcc cross compiler
Emulator: Qemu
Bootloader: GRUB
Assembler: Non-Cygwin NASM

Personally, I use:
Editor: GVim
Shell: bash (on linux)
Compiler: GCC (i586-elf or i586-pc-ignite)
Emulator: Qemu
Bootloader: Syslinux
Assembler: NASM, GNU AS
Version Control: Git
And, of course, gdb/cgdb.

IDE/editor: Geany
Host OS: ubuntu 10.10
Assembler: FASM
Compiler: gcc C
Bootloader: gnu grub 2
Version control: git
Build system: bash
Virtual Machine: Qemu, occasionally VirtualBox OSE

Sounds like I am fairly similar to many of the types living here

vim/gcc/nasm/make/gdb/bochs/qemu

The one tool that I wouldn't survive without, however, is GNU screen.

IDE, build system, compiler, linker: Visual Studio 2010
Assembler: JWASM
Bootloader: Homemade
Emulator: VirtualBox
Debugging: Emulated serial port going through Named Pipe TCP Proxy to TeraTerm.
Host OS: Windows Vista Business SP1

At the end of the build process, a homemade tool converts the executable to a flat binary, and another creates a FAT floppy image containing the required files.

Host OS: Ubuntu 11.04
Assembler: NASM
Compiler: GCC
Linker: LD
Virtual Machine: VirtualBox OSE
TextEditor: gedit
And the most useful tool of all: The Internet!

IDE/editor: Eclipse
Host OS: Lion
Assembler: gas
Compiler: gcc
Bootloader: gnu grub in an iso file
Version control: svn
Build system: make
Virtual Machine: vmware booting from iso file
Real Machine: a few, but mainly my Core 2 quad machine booting from USB
Debugging: mainly stare-down and kprintf

Environment

• Host OS: Windows 7
  Editor: Vim
  Shell: MSYS

Toolchain

• Compilers: GCC, clang
  Assembler: Homebrew ASM386 clone
  Build system: CMake (subject to change)
  Version control: git (subject to change)

Testing

• Emulator: QEMU
  PXE server: Tftpd64

Documentation

• LaTeX

Physical System: Intel D101GGC, Pentium D processor 3.06 GHz x 2
Platform: Portable Windows XP live with 32 bit apps support
Emulators: Microsoft Virtual PC, BOCHS, QEMU and VMWARE (that's right, all of these. Each show different symptoms for a bug)
Compiler: GNU C Compiler 4.4.2
Linker: GNU Linker 2.20
Assembler: NASM

Environment:
Host OS: Windows 7 / Kubuntu
IDE/Editor: Eclipse
Shell: Cygwin (windows), bash (ubuntu)

Building:
Assembler: NASM
Linker: LD cross linker
Compiler: GCC cross compiler
Build system: shell script

Testing:
Debugger: ConsoleWrite, with some Log(), Error() and Panic() macros; when that fails, Bochs.
Emulator: VirtualBox for testing
Real machines: My old trusty Compaq (pentium 2 @400 mhz, 128mb ram, 6gb hdd)

Version control: Dropbox folder with bz2 packed builds
Research: the interwebs

OS: Windows XP
Toolchain: gcc, nasm
Editor: GNU Emacs 22
Version control: RCS
Build automation: makefiles, elisp code and batch files

Microsoft compiler, ml64 and jwasm assemblers, jwlink linker and bochs of course. I am thinking of writing myself a bespoke make utility.

The linker is conceivably the most versatile one on the face of the planet. You can put almost any object format in, and get almost any executable format out. In my case it is PE in and elf out.

Holy odd man out syndrome.

Visual Studio 2010. The only thing that I don't use out of that toolchain is the assembler, where I drop in NASM instead. I'm developing on a Windows 7 laptop, using Windows VPC, Bochs, and Qemu for testing. I use RawWrite to write out to floppy (yes, I'm still using floppies - sigh).

It makes finding assistance on tricky topics harder, but I am enjoying proving that OSDev can be done on something outside of your typical *nix/gcc/vim/... combination.

HostOS: Windows XP/Vista/7
Tools: OpenWatcom WASM/C/C++/IDE
Editor: Mbedit or OpenWatcom editor
Testing: Real hardware only (4-core AMD Athlon, Intel Core-duo, various AMD Geode PPCs)
Debugging: Kernel debugger and OpenWatcom debugger over TCP/IP
Booting: Native HD, native floppy, GRUB
Image creation: Home-made cfg2bin tool that creates single boot-image from individual files.
Mass disc creation: Paragon Partition manager by loading first sectors from file.
Installed base: About 150 installations