diff --git a/docs/busybox.net/news.html b/docs/busybox.net/news.html
index 8f756f0..4946da1 100644
--- a/docs/busybox.net/news.html
+++ b/docs/busybox.net/news.html
@@ -44,10 +44,10 @@
     <p>New applets:
       <ul>
 	<li>flash_eraseall: by Sebastian Andrzej Siewior (bigeasy AT linutronix.de)</li>
-	<li>acpid,mkdosfs (aka mkfs.vfat),tunctl: by Vladimir</li>
-	<li>ftpd: by Adam Tkac</li>
+	<li>acpid, mkdosfs, tunctl: by Vladimir</li>
+	<li>ftpd: by Adam Tkac (vonsch AT gmail.com)</li>
 	<li>timeout: by Roberto Foglietta</li>
-	<li>ionice: adapted from Linux kernel' example by Walter Harms</li>
+	<li>ionice: adapted from Linux kernel example by Walter Harms</li>
 	<li>mkpasswd: synonym to cryptpw. mkpasswd is in Debian, OTOH cryptpw was added to busybox earlier. Trying to make both camps happy by making those two applets just aliases. They are command-line compatible</li>
       </ul>
 
@@ -55,16 +55,18 @@
 
     <p>lash and msh are deprecated, please migrate to hush.
 
-    <p>hush had many, many fixes and features added: here documents, arithmetic evaluation, function support, and all this works on NOMMU too, safely: 100kb-sized `command` and heredocs. Here document support, arithmetic evaluation, improved ${var} ops, other fixes are by Mike Frysinger (vapier AT gentoo.org).
+    <p>hush had many, many fixes and features added: here documents, arithmetic evaluation, function support, and all this works on NOMMU too, safely, including 100kb-sized `command` and here documents. Here document support, arithmetic evaluation, improved ${var} operations, other fixes are by Mike Frysinger (vapier AT gentoo.org).
 
     <p>Other changes:
       <ul>
 	<li>libbb: unify concurrent-safe update of /etc/{passwd,group,[g]shadow}. By Tito (farmatito AT tiscali.it)</li>
-	<li>libbb/sha1/256/512: major code shrink</li>
+	<li>libbb/sha{1,256,512}: major code shrink</li>
 	<li>libbb/lineedit: make history saving/loading concurrent-safe</li>
 	<li>libbb: shrink linked list ops. By xmaks AT email.cz</li>
-	<li>libbb: str2sockaddr shuld accept [IPv6] addr without port - wget 'ftp://[::1]/file' needs that to work</li>
+	<li>libbb: str2sockaddr should accept [IPv6] addr without port - wget 'ftp://[::1]/file' needs that to work</li>
 	<li>libbb: make bb_info_msg do atomic, unbuffered writes</li>
+	<li>util-linux/volumeid: abort early on read failures. Should help with probing missing fdd's</li>
+	<li>util-linux/volumeid: fix bug 249 "findfs finds the wrong partition"</li>
 	<li>adduser: allow adding to group 0; don't _create_ /etc/shadow, only append data if it exists</li>
 	<li>ash: fix mishandled ^C</li>
 	<li>ash: fix "ash -c 'exec 1&gt;&amp;0'" complaining that fd 0 is busy</li>
@@ -72,7 +74,6 @@
 	<li>ash: fix a case where we close wrong descriptor</li>
 	<li>ash: fix bad interaction between ash -c '....&amp;' and bash compat</li>
 	<li>ash: fix miscalculation of memory needed for eval tree. Found by Timo Teras (timo.teras AT iki.fi)</li>
-	<li>ash: in dotrap(), do not clear gotsig[] for SIGINT if there is no handler for it, otherwise raise interrupt gets confused later</li>
 	<li>ash: make dot command search current directory first, as bash does</li>
 	<li>ash: make evaltree save/restore int suppression depth. Hopefully this fixes bug 189</li>
 	<li>ash: printf builtin with no arguments should not exit</li>
@@ -84,16 +85,16 @@
 	<li>chat: recognize RECORD directive</li>
 	<li>cksum, printenv: report errors via exitcode</li>
 	<li>cpio: add -p, -0 and -L options</li>
-	<li>crond,crontab: make cron directory location configurable</li>
+	<li>crond, crontab: make cron directory location configurable</li>
 	<li>crond: correct more of logfile to 0666 (as usual, umask allows user to remove unwanted bits)</li>
 	<li>crond: put tasks in separate process groups</li>
 	<li>dc: fix the "base 2" patch omission of base not being set</li>
 	<li>depmod: accept and ignore -r. Linux kernel build needs this</li>
 	<li>depmod: fix -b option. By timo.teras AT iki.fi</li>
-	<li>udhcpd,dumpleases: write and use 64-bit current time in lease file. without it, determination of remaining lease time is unreliable</li>
-	<li>udhcpd: remember and record hostnames</li>
-	<li>dhcprelay: fix usage text. Simplify and make code more readable</li>
-	<li>dumpleases: fix -a option; show hostnames</li>
+	<li>udhcpd, dumpleases: write and use 64-bit current time in lease file. Without it, determination of remaining lease time is unreliable</li>
+	<li>udhcpd: remember hostnames of clients</li>
+	<li>dumpleases: fix -a option</li>
+	<li>dumpleases: show hostnames</li>
 	<li>udhcpc: fix a problem where we don't open listening socket fast enough</li>
 	<li>udhcpc: stop filtering environment passed to the script</li>
 	<li>udhcpd: add code which rejects lease files with suspicious or old timestamp</li>
@@ -102,7 +103,7 @@
 	<li>dpkg: better and shorter code to compare versions. Taken from "official" dpkg by Eugene T. Bordenkircher (eugebo AT gmail.com)</li>
 	<li>du: fix "du /dir /dir" case</li>
 	<li>env: support -uVAR=VAL</li>
-	<li>expand: fix incorrect expansion exactly on tab boundary; shrink the code</li>
+	<li>expand, unexpand: fix incorrect expansion in some cases</li>
 	<li>expr: a bit more robust handling of regexps with groups. Closes bug 87</li>
 	<li>find: support --mindepth</li>
 	<li>getty: fix handling of speed 0; stop using non-portable way of setting speeds</li>
@@ -119,7 +120,6 @@
 	<li>init: test for vt terminal with VT_OPENQRY, assume that anything else is TERM=vt102, not TERM=linux. Closes bug 195</li>
 	<li>inotifyd: add x, o, and u events</li>
 	<li>inotifyd: fix buffer overflow and "unreaped zombies" problem</li>
-	<li>inotifyd: exit if x event happened for all files</li>
 	<li>inotifyd: conserve resourses by closing unused inotify descriptors</li>
 	<li>insmod/modprobe: do not pass NULL to kernel as module parameter</li>
 	<li>ip: in "ip rule add from all table 1", "all" is taken as 0.0.0.0/32, whereas "any" and "default" would be 0.0.0.0/0. They must be all 0.0.0.0/0. Closes bug 57</li>
@@ -134,14 +134,11 @@
 	<li>mdev: ignore events with "$SUBSYSTEM" == "firmware" &amp;&amp; "$ACTION" == "remove"</li>
 	<li>mdev: provide $SUBSYSTEM. By Vladimir</li>
 	<li>modprobe/insmod for 2.4: support compressed modules. By Guenter (lists AT gknw.net)</li>
-	<li>modprobe: emit "can't open 'modules.dep': (errno)" instead of "module not found"</li>
 	<li>modprobe: rework/speedup by Timo Teras (timo.teras AT iki.fi)</li>
 	<li>modutils-24: fix bad interaction of xzalloc with xrealloc_vector</li>
-	<li>mount: support "-O option"</li>
-	<li>mount: stop trying to mount swap partitions</li>
-	<li>mount: fix CIFS support</li>
+	<li>mount: support "-O option", stop trying to mount swap partitions, fix CIFS support</li>
 	<li>mountpoint: add -n option. By Vladimir</li>
-	<li>nslookup: allow usage of IPv6 addresses or hostnames for DNS server name; allow for port specification. Tested to work: "nslookup google.com [::1]:5353". glibc + IPv6 address of DNS server still does not work</li>
+	<li>nslookup: allow usage of IPv6 addresses or hostnames for DNS server name; allow for port specification. Tested to work on uclibc svn: "nslookup google.com [::1]:5353". glibc + IPv6 address of DNS server still does not work</li>
 	<li>popmaildir: fix several grave bugs with using memory past end of malloc block</li>
 	<li>printf: fix 1.12.0 breakage (from %*d fix), it was misinterpreting "*"</li>
 	<li>printf: make integer format strings print long long-sized values</li>
@@ -154,7 +151,7 @@
 	<li>sysctl: fix another corner case with "dots and slashes"</li>
 	<li>sysctl: fix broken -p [file]. Closes bug 231</li>
 	<li>sysctl: support recursing if name is a directory: "sysctl net.ipv4.conf". Patch by xmaks AT email.cz</li>
-	<li>syslogd: comment out file locking; make signal handling syncronous</li>
+	<li>syslogd: make signal handling syncronous</li>
 	<li>syslogd: create logfile with 0666 (affected by umask as usual), not 0600</li>
 	<li>tail: fix tail +N syntax not working. Closes bug 221</li>
 	<li>tar: do not change new tarfile's mode, GNU tar doesn't do it</li>
@@ -164,21 +161,15 @@
 	<li>tftp: when we infer local name from remote (-r [/]path/path/file), strip path. This mimics wget and is generally more intuitive</li>
 	<li>timeout: fix parsing of -t NUM on MMU</li>
 	<li>top: make it work again on 2.4 kernels. Closes bug 125</li>
-	<li>tr: fix overflow in expand and complement, fix stop after [:class:]</li>
-	<li>tr: support -C as synonym to -c</li>
-	<li>tr: support [:xdigit:], fix handling of ranges and [x]'s</li>
+	<li>tr: fix overflow in expand and complement, fix stop after [:class:], fix handling of ranges and [x]'s</li>
+	<li>tr: support -C as synonym to -c, support [:xdigit:]</li>
 	<li>traceroute: rewrite. Do not emit raw IP packets, instead send UDP or ICMP packets and rely on the kernel to form IP headers, select source IP and interface</li>
-	<li>uname: add support for -i and -o, fix printing of unknown -p value with -a option</li>
-	<li>uname: support long options</li>
-	<li>unexpand: fix incorrect expansion</li>
+	<li>uname: add support for -i and -o, fix printing of unknown -p value with -a option, support long options</li>
 	<li>unzip: fix thinko with le/be conv and size. Closes bug 129</li>
 	<li>vi: fix several instances of major goof: when text grows, text[] might get reallocated! We were keeping around pointers to old place</li>
 	<li>vi: speedup and code shrink. By Walter Harms</li>
-	<li>volume_id: abort early on read failures. Should help with probing missing fdd's</li>
-	<li>volumeid: fix bug 249 "findfs finds the wrong partition"</li>
 	<li>wget: --post-data support. By Harald Kuthe (harald-tuxbox AT arcor.de)</li>
-	<li>wget: fix --header handling</li>
-	<li>wget: more robust EINTR detection</li>
+	<li>wget: fix --header handling, more robust EINTR detection</li>
       </ul>
     </p>
 
