Index: src/java/org/apache/solr/request/PHPResponseWriter.java
===================================================================
--- src/java/org/apache/solr/request/PHPResponseWriter.java	(revision 0)
+++ src/java/org/apache/solr/request/PHPResponseWriter.java	(revision 0)
@@ -0,0 +1,39 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.solr.request;
+
+import java.io.Writer;
+import java.io.IOException;
+
+import org.apache.solr.util.NamedList;
+
+public class PHPResponseWriter implements QueryResponseWriter {
+  static String CONTENT_TYPE_PHP_UTF8="text/x-php;charset=UTF-8";
+
+  public void init(NamedList n) {
+    /* NOOP */
+  }
+  
+ public void write(Writer writer, SolrQueryRequest req, SolrQueryResponse rsp) throws IOException {
+    PHPWriter w = new PHPWriter(writer, req, rsp);
+    w.writeResponse();
+  }
+
+  public String getContentType(SolrQueryRequest request, SolrQueryResponse response) {
+    return CONTENT_TYPE_TEXT_UTF8;
+  }
+}
Index: src/java/org/apache/solr/request/JSONResponseWriter.java
===================================================================
--- src/java/org/apache/solr/request/JSONResponseWriter.java	(revision 521990)
+++ src/java/org/apache/solr/request/JSONResponseWriter.java	(working copy)
@@ -293,7 +293,7 @@
   }
 
 
-  private static class MultiValueField {
+  protected static class MultiValueField {
     final SchemaField sfield;
     final ArrayList<Fieldable> fields;
     MultiValueField(SchemaField sfield, Fieldable firstVal) {
@@ -792,3 +792,254 @@
     writer.write('\'');
   }
 }
+
+class PHPWriter extends JSONWriter {
+  public PHPWriter(Writer writer, SolrQueryRequest req, SolrQueryResponse rsp) {
+    super(writer, req, rsp);
+  }
+
+  @Override
+  public void writeNull(String name) throws IOException {
+    writer.write("null");
+  }
+
+  @Override
+  protected void writeKey(String fname, boolean needsEscaping) throws IOException {
+    writeStr(null, fname, needsEscaping);
+    writer.write(" => ");
+  }
+
+  @Override
+  public void writeStr(String name, String val, boolean needsEscaping) throws IOException {
+    
+    writer.write('\'');
+    if (needsEscaping) {
+      for (int i=0; i<val.length(); i++) {
+        char ch = val.charAt(i);
+        switch(ch) {
+          case '\'':
+          case '\\': writer.write('\\'); writer.write(ch); break;
+          default: writer.write(ch); break;
+        }
+      }
+    } else {
+      writer.write(val);
+    }
+    writer.write('\'');
+  }
+  
+  @Override
+  public void writeNamedList(String name, NamedList val) throws IOException {
+  //Only one method is allowed
+      writeNamedListAsMapMangled(name,val);
+    }
+  @Override
+  public void writeDocList(String name, DocList ids, Set<String> fields, Map otherFields) throws IOException {
+    boolean includeScore=false;
+    if (fields!=null) {
+      includeScore = fields.contains("score");
+      if (fields.size()==0 || (fields.size()==1 && includeScore) || fields.contains("*")) {
+        fields=null;  // null means return all stored fields
+      }
+    }
+
+    int sz=ids.size();
+
+    writer.write("array(");
+    incLevel();
+    writeKey("numFound",false);
+    writeInt(null,ids.matches());
+    writer.write(',');
+    writeKey("start",false);
+    writeInt(null,ids.offset());
+
+    if (includeScore) {
+      writer.write(',');
+      writeKey("maxScore",false);
+      writeFloat(null,ids.maxScore());
+    }
+    writer.write(',');
+    // indent();
+    writeKey("docs",false);
+    writer.write("array(");
+
+    incLevel();
+    boolean first=true;
+    
+    SolrIndexSearcher searcher = req.getSearcher();
+    DocIterator iterator = ids.iterator();
+    for (int i=0; i<sz; i++) {
+      int id = iterator.nextDoc();
+      Document doc = searcher.doc(id, fields);
+
+      if (first) {
+        first=false;
+      } else {
+        writer.write(',');
+      }
+      indent();
+      writeDoc(null, doc, fields, (includeScore ? iterator.score() : 0.0f), includeScore);
+    }
+    decLevel();
+    writer.write(')');
+
+    if (otherFields !=null) {
+      writeMap(null, otherFields, true, false);
+    }
+
+    decLevel();
+    indent();
+    writer.write(')');
+  }
+
+   @Override
+   public void writeNamedListAsMapMangled(String name, NamedList val) throws IOException {
+    int sz = val.size();
+    writer.write("array(");
+    incLevel();
+
+    // In JSON objects (maps) we can't have null keys or duplicates...
+    // map null to "" and append a qualifier to duplicates.
+    //
+    // a=123,a=456 will be mapped to {a=1,a__1=456}
+    // Disad: this is ambiguous since a real key could be called a__1
+    //
+    // Another possible mapping could aggregate multiple keys to an array:
+    // a=123,a=456 maps to a=[123,456]
+    // Disad: this is ambiguous with a real single value that happens to be an array
+    //
+    // Both of these mappings have ambiguities.
+    HashMap<String,Integer> repeats = new HashMap<String,Integer>(4);
+
+    boolean first=true;
+    for (int i=0; i<sz; i++) {
+      String key = val.getName(i);
+      if (key==null) key="";
+
+      if (first) {
+        first=false;
+        repeats.put(key,0);
+      } else {
+        writer.write(',');
+
+        Integer repeatCount = repeats.get(key);
+        if (repeatCount==null) {
+          repeats.put(key,0);
+        } else {
+          String newKey = key;
+          int newCount = repeatCount;
+          do {  // avoid generated key clashing with a real key
+            newKey = key + ' ' + (++newCount);
+            repeatCount = repeats.get(newKey);
+          } while (repeatCount != null);
+
+          repeats.put(key,newCount);
+          key = newKey;
+        }
+      }
+
+      indent();
+      writeKey(key, true);
+      writeVal(key,val.getVal(i));
+    }
+
+    decLevel();
+    writer.write(')');
+  }
+    @Override
+    public void writeDoc(String name, Collection<Fieldable> fields, Set<String> returnFields, Map pseudoFields) throws IOException {
+    writer.write("array(");
+    incLevel();
+
+    HashMap<String, MultiValueField> multi = new HashMap<String, MultiValueField>();
+
+    boolean first=true;
+
+    for (Fieldable ff : fields) {
+      String fname = ff.name();
+      if (returnFields!=null && !returnFields.contains(fname)) {
+        continue;
+      }
+
+      // if the field is multivalued, it may have other values further on... so
+      // build up a list for each multi-valued field.
+      SchemaField sf = schema.getField(fname);
+      if (sf.multiValued()) {
+        MultiValueField mf = multi.get(fname);
+        if (mf==null) {
+          mf = new MultiValueField(sf, ff);
+          multi.put(fname, mf);
+        } else {
+          mf.fields.add(ff);
+        }
+      } else {
+        // not multi-valued, so write it immediately.
+        if (first) {
+          first=false;
+        } else {
+          writer.write(',');
+        }
+        indent();
+        writeKey(fname,true);
+        sf.write(this, fname, ff);
+      }
+    }
+
+    for(MultiValueField mvf : multi.values()) {
+      if (first) {
+        first=false;
+      } else {
+        writer.write(',');
+      }
+
+      indent();
+      writeKey(mvf.sfield.getName(), true);
+
+      boolean indentArrElems=false;
+      if (doIndent) {
+        // heuristic... TextField is probably the only field type likely to be long enough
+        // to warrant indenting individual values.
+        indentArrElems = (mvf.sfield.getType() instanceof TextField);
+      }
+
+      writer.write("array(");
+      boolean firstArrElem=true;
+      incLevel();
+
+      for (Fieldable ff : mvf.fields) {
+        if (firstArrElem) {
+          firstArrElem=false;
+        } else {
+          writer.write(',');
+        }
+        if (indentArrElems) indent();
+        mvf.sfield.write(this, null, ff);
+      }
+      writer.write(')');
+      decLevel();
+    }
+
+    if (pseudoFields !=null && pseudoFields.size()>0) {
+      writeMap(null,pseudoFields,true,first);
+    }
+
+    decLevel();
+    writer.write(')');
+  }
+  @Override
+  public void writeArray(String name, Iterator val) throws IOException {
+    writer.write("array(");
+    incLevel();
+    boolean first=true;
+    while( val.hasNext() ) {
+      if( !first ) indent();
+      writeVal(null, val.next());
+      if( val.hasNext() ) {
+        writer.write(',');
+      }
+      first=false;
+    }
+    decLevel();
+    writer.write(')');
+  }
+}
\ No newline at end of file
Index: example/solr/conf/solrconfig.xml
===================================================================
--- example/solr/conf/solrconfig.xml	(revision 521990)
+++ example/solr/conf/solrconfig.xml	(working copy)
@@ -398,6 +398,8 @@
   <queryResponseWriter name="xslt" class="org.apache.solr.request.XSLTResponseWriter">
     <int name="xsltCacheLifetimeSeconds">5</int>
   </queryResponseWriter> 
+  
+  <queryResponseWriter name="php" class="org.apache.solr.request.PHPResponseWriter"/>
     
   <!-- config for the admin interface --> 
   <admin>