Index: trunk/engines/engine.go
===================================================================
--- trunk/engines/engine.go	(revision 14)
+++ trunk/engines/engine.go	(revision 15)
@@ -2,6 +2,6 @@
 
 type TranslationResult struct {
-	SourceLanguage Language
-	TranslatedText string
+	SourceLanguage string `json:"source_language"`
+	TranslatedText string `json:"translated_text"`
 }
 
@@ -9,8 +9,16 @@
 	InternalName() string
 	DisplayName() string
-	SourceLanguages() ([]Language, error)
-	TargetLanguages() ([]Language, error)
-	Translate(text string, from, to Language) (TranslationResult, error)
-	SupportsAutodetect() bool
-	DetectLanguage(text string) (Language, error)
+	SourceLanguages() (Language, error)
+	TargetLanguages() (Language, error)
+	Translate(text string, from, to string) (TranslationResult, error)
+	DetectLanguage(text string) (string, error)
 }
+
+type Language map[string]string
+
+var Engines = map[string]Engine{
+	"google":   &GoogleTranslate{},
+	"icibia":   &ICIBA{},
+	"libre":    &LibreTranslate{},
+	"reverseo": &Reverso{},
+}
Index: trunk/engines/google.go
===================================================================
--- trunk/engines/google.go	(revision 14)
+++ trunk/engines/google.go	(revision 15)
@@ -15,5 +15,5 @@
 func (_ *GoogleTranslate) DisplayName() string { return "Google" }
 
-func (_ *GoogleTranslate) getLangs(type_ string) ([]Language, error) {
+func (_ *GoogleTranslate) getLangs(type_ string) (Language, error) {
 	var langsType string
 	switch type_ {
@@ -28,10 +28,5 @@
 	}
 
-	requestURL, err := url.Parse("https://translate.google.com/m")
-
-	if err != nil {
-		// The URL is constant, so it should never fail.
-		panic(err)
-	}
+	requestURL, _ := url.Parse("https://translate.google.com/m")
 
 	query := url.Values{}
@@ -54,5 +49,5 @@
 	}
 
-	var langs []Language
+	var langs Language
 
 	doc.Find(".language-item").Each(func(_ int, s *goquery.Selection) {
@@ -78,5 +73,5 @@
 		}
 
-		langs = append(langs, Language{Name: a.Text(), Code: langCode})
+		langs[langCode] = a.Text()
 	})
 
@@ -84,28 +79,25 @@
 }
 
-func (e *GoogleTranslate) SourceLanguages() ([]Language, error) {
+func (e *GoogleTranslate) SourceLanguages() (Language, error) {
 	return e.getLangs("source")
 }
 
-func (e *GoogleTranslate) TargetLanguages() ([]Language, error) {
+func (e *GoogleTranslate) TargetLanguages() (Language, error) {
 	return e.getLangs("target")
 }
 
-func (_ *GoogleTranslate) SupportsAutodetect() bool { return true }
+func (_ *GoogleTranslate) DetectLanguage(text string) (string, error) { return "", nil }
 
-func (_ *GoogleTranslate) DetectLanguage(text string) (Language, error) { return Language{}, nil }
+func (_ *GoogleTranslate) Translate(text string, from, to string) (TranslationResult, error) {
+	requestURL, _ := url.Parse("https://translate.google.com/m")
 
-func (_ *GoogleTranslate) Translate(text string, from, to Language) (TranslationResult, error) {
-	requestURL, err := url.Parse("https://translate.google.com/m")
-
-	if err != nil {
-		// The URL is constant, so it should never fail.
-		panic(err)
+	if from == "" {
+		from = "auto"
 	}
 
 	query := url.Values{}
-	query.Add("sl", from.Code)
-	query.Add("tl", to.Code)
-	query.Add("hl", to.Code)
+	query.Add("sl", from)
+	query.Add("tl", to)
+	query.Add("hl", to)
 	query.Add("q", text)
 	requestURL.RawQuery = query.Encode()
Index: trunk/engines/iciba.go
===================================================================
--- trunk/engines/iciba.go	(revision 14)
+++ trunk/engines/iciba.go	(revision 15)
@@ -17,5 +17,5 @@
 func (_ *ICIBA) DisplayName() string { return "iCIBA" }
 
-var icibaLanguages = []Language{
+var icibaLanguages = Language{
 	// ICIBA does have an API, but they return Chinese names.
 	// For languages already present in Google translate, the English
@@ -26,197 +26,195 @@
 	// due to conflict between ISO-639 table and Chinese label
 	// one "//" means on iciba but not on google
-	{Name: "Achinese", Code: "ace"},       //
-	{Name: "Achuar-Shiwiar", Code: "acu"}, //
-	{Name: "Afrikaans", Code: "af"},
-	{Name: "Aguaruna", Code: "agr"}, //
-	{Name: "Akawaio", Code: "ake"},  //
-	{Name: "Albanian", Code: "sq"},
-	{Name: "Amharic", Code: "am"},
-	{Name: "Arabic", Code: "ar"},
-	{Name: "Armenian", Code: "hy"},
-	{Name: "Azerbaijani", Code: "az"},
-	{Name: "Barasana-Eduria", Code: "bsn"}, //
-	{Name: "Bashkir", Code: "ba"},          //
-	{Name: "Basque", Code: "eu"},
-	{Name: "Belarusian", Code: "be"},
-	{Name: "Bemba", Code: "bem"}, //
-	{Name: "Bengali", Code: "bn"},
-	{Name: "Berber", Code: "ber"}, //
-	{Name: "Bislama", Code: "bi"}, //
-	{Name: "Bosnian", Code: "bs"},
-	{Name: "Breton", Code: "br"}, //
-	{Name: "Bulgarian", Code: "bg"},
-	{Name: "Cabécar", Code: "cjp"}, //
-	{Name: "Cantonese", Code: "yue"},
-	{Name: "Catalan", Code: "ca"},
-	{Name: "Cebuano", Code: "ceb"},
-	{Name: "Chamorro", Code: "cha"}, //
-	{Name: "Cherokee", Code: "chr"}, //
-	{Name: "Chichewa", Code: "ny"},
-	{Name: "Chinese (Simplified)", Code: "zh"},   // "zh-cn" on Google
-	{Name: "Chinese (Traditional)", Code: "cht"}, // "zh-tw" on Google
-	{Name: "Chuvash", Code: "cv"},
-	{Name: "Coptic", Code: "cop"}, //
-	{Name: "Corsican", Code: "co"},
-	{Name: "Croatian", Code: "hr"},
-	{Name: "Czech", Code: "cs"},
-	{Name: "Danish", Code: "da"},
-	{Name: "Dhivehi", Code: "dv"}, //
-	{Name: "Dinka", Code: "dik"},  //
-	{Name: "Dutch", Code: "nl"},
-	{Name: "Dzongkha", Code: "dz"}, //
-	{Name: "English", Code: "en"},
-	{Name: "Esperanto", Code: "eo"},
-	{Name: "Estonian", Code: "et"},
-	{Name: "Ewe", Code: "ee"},       //
-	{Name: "Faroese", Code: "fo"},   //
-	{Name: "Fijian", Code: "fj"},    //
-	{Name: "Filipino", Code: "fil"}, // "tl" on Google
-	{Name: "Finnish", Code: "fi"},
-	{Name: "French", Code: "fr"},
-	{Name: "Frisian", Code: "fy"},
-	{Name: "Galela", Code: "gbi"}, //
-	{Name: "Galician", Code: "gl"},
-	{Name: "Ganda", Code: "lg"},    //
-	{Name: "Georgian", Code: "jy"}, // "ka" on Google
-	{Name: "German", Code: "de"},
-	{Name: "Greek", Code: "el"},
-	{Name: "Guerrero Amuzgo", Code: "amu"}, //
-	{Name: "Gujarati", Code: "gu"},
-	{Name: "Haitian Creole", Code: "ht"},
-	{Name: "Hausa", Code: "ha"},
-	{Name: "Hawaiian", Code: "haw"},
-	{Name: "Hebrew", Code: "he"}, // "iw" on Google
-	{Name: "Hindi", Code: "hi"},
-	{Name: "Hmong Daw", Code: "mww"}, //
-	{Name: "Hmong", Code: "hmn"},     // not in iciba
-	{Name: "Hungarian", Code: "hu"},
-	{Name: "Icelandic", Code: "is"},
-	{Name: "Igbo", Code: "ig"},
-	{Name: "Indonesian", Code: "id"},
-	{Name: "Irish", Code: "ga"},
-	{Name: "Italian", Code: "it"},
-	{Name: "Jacalteco", Code: "jac"}, //
-	{Name: "Japanese", Code: "ja"},
-	{Name: "Javanese", Code: "jv"}, // "jw" on Google
-	{Name: "Kabyle", Code: "kab"},  //
-	{Name: "Kannada", Code: "kn"},
-	{Name: "Kaqchikel", Code: "cak"},        //
-	{Name: "Kazakh", Code: "ka"},            // Google only has "kk"
-	{Name: "Kazakh (Cyrillic)", Code: "kk"}, // Google has it as just "Kazakh"
-	{Name: "Kekchí", Code: "kek"},           //
-	{Name: "Khmer", Code: "km"},
-	{Name: "Kinyarwanda", Code: "rw"},
-	{Name: "Kongo", Code: "kg"}, //
-	{Name: "Korean", Code: "ko"},
-	{Name: "Kurdish (Kurmanji)", Code: "ku"},
-	{Name: "Kyrgyz", Code: "ky"},
-	{Name: "Lao", Code: "lo"},
-	{Name: "Latin", Code: "la"},
-	{Name: "Latvian", Code: "lv"},
-	{Name: "Lingala", Code: "ln"}, //
-	{Name: "Lithuanian", Code: "lt"},
-	{Name: "Lukpa", Code: "dop"}, //
-	{Name: "Luxembourgish", Code: "lb"},
-	{Name: "Macedonian", Code: "mk"},
-	{Name: "Malagasy", Code: "mg"},
-	{Name: "Malay", Code: "ms"},
-	{Name: "Malayalam", Code: "ml"},
-	{Name: "Maltese", Code: "mt"},
-	{Name: "Mam", Code: "mam"}, //
-	{Name: "Manx", Code: "gv"}, //
-	{Name: "Maori", Code: "mi"},
-	{Name: "Marathi", Code: "mr"},
-	{Name: "Mari (Eastern)", Code: "mhr"}, //
-	{Name: "Mari (Western)", Code: "mrj"}, //
-	{Name: "Mongolian", Code: "mn"},
-	{Name: "Montenegrin", Code: "me"}, //
-	{Name: "Myanmar (Burmese)", Code: "my"},
-	{Name: "Nahuatl", Code: "nhg"}, //
-	{Name: "Ndyuka", Code: "djk"},  //
-	{Name: "Nepali", Code: "ne"},
-	{Name: "Norwegian", Code: "no"},
-	{Name: "Odia (Oriya)", Code: "or"},
-	{Name: "Ojibwa", Code: "ojb"},
-	{Name: "Oromo", Code: "om"},       //
-	{Name: "Ossetian", Code: "os"},    //
-	{Name: "Paite", Code: "pck"},      //
-	{Name: "Papiamento", Code: "pap"}, //
-	{Name: "Pashto", Code: "ps"},
-	{Name: "Persian", Code: "fa"},
-	{Name: "Polish", Code: "pl"},
-	{Name: "Portuguese", Code: "pt"},
-	{Name: "Potawatomi", Code: "pot"}, //
-	{Name: "Punjabi", Code: "pa"},
-	{Name: "Querétaro Otomi", Code: "otq"},     //
-	{Name: "Quiché", Code: "quc"},              //
-	{Name: "Quichua", Code: "quw"},             //
-	{Name: "Quiotepec Chinantec", Code: "chq"}, //
-	{Name: "Romani", Code: "rmn"},              //
-	{Name: "Romanian", Code: "ro"},
-	{Name: "Rundi", Code: "rn"}, //
-	{Name: "Russian", Code: "ru"},
-	{Name: "Samoan", Code: "sm"},
-	{Name: "Sango", Code: "sg"}, //
-	{Name: "Scots Gaelic", Code: "gd"},
-	{Name: "Serbian", Code: "sr"},
-	{Name: "Seselwa Creole French", Code: "crs"}, //
-	{Name: "Sesotho", Code: "st"},
-	{Name: "Shona", Code: "sn"},
-	{Name: "Shuar", Code: "jiv"}, //
-	{Name: "Sindhi", Code: "sd"},
-	{Name: "Sinhala", Code: "si"},
-	{Name: "Slovak", Code: "sk"},
-	{Name: "Slovenian", Code: "sl"},
-	{Name: "Somali", Code: "so"},
-	{Name: "Spanish", Code: "es"},
-	{Name: "Sundanese", Code: "su"},
-	{Name: "Swahili", Code: "sw"},
-	{Name: "Swedish", Code: "sv"},
-	{Name: "Syriac", Code: "syc"},    // considered "extinct" but is somehow supported
-	{Name: "Tachelhit", Code: "shi"}, //
-	{Name: "Tahitian", Code: "ty"},   //
-	{Name: "Tajik", Code: "tg"},
-	{Name: "Tamil", Code: "ta"},
-	{Name: "Tatar", Code: "tt"},
-	{Name: "Telugu", Code: "te"},
-	{Name: "Tetum", Code: "tet"}, //
-	{Name: "Thai", Code: "th"},
-	{Name: "Tigre", Code: "ti"},      //
-	{Name: "Tiwi", Code: "tw"},       //
-	{Name: "Tok Pisin", Code: "tpi"}, //
-	{Name: "Tonga", Code: "to"},      //
-	{Name: "Tsonga", Code: "ts"},
-	{Name: "Tswana", Code: "tn"}, //
-	{Name: "Turkish", Code: "tr"},
-	{Name: "Turkmen", Code: "tk"},
-	{Name: "Udmurt", Code: "udm"}, //
-	{Name: "Ukrainian", Code: "uk"},
-	{Name: "Uma", Code: "ppk"}, //
-	{Name: "Urdu", Code: "ur"},
-	{Name: "Uspanteco", Code: "usp"}, //
-	{Name: "Uyghur", Code: "uy"},     // "ug" on Google
-	{Name: "Uzbek", Code: "uz"},
-	{Name: "Venda", Code: "ve"}, //
-	{Name: "Vietnamese", Code: "vi"},
-	{Name: "Waray", Code: "war"}, //
-	{Name: "Welsh", Code: "cy"},
-	{Name: "Wolaitta", Code: "wal"}, //
-	{Name: "Wolof", Code: "wol"},
-	{Name: "Xhosa", Code: "xh"},
-	{Name: "Yiddish", Code: "yi"},
-	{Name: "Yoruba", Code: "yo"},
-	{Name: "Yucatán Maya", Code: "yua"}, //
-	{Name: "Zarma", Code: "dje"},        //
-	{Name: "Zulu", Code: "zu"},
+	"ace": "Achinese",       //
+	"acu": "Achuar-Shiwiar", //
+	"af":  "Afrikaans",
+	"agr": "Aguaruna", //
+	"ake": "Akawaio",  //
+	"sq":  "Albanian",
+	"am":  "Amharic",
+	"ar":  "Arabic",
+	"hy":  "Armenian",
+	"az":  "Azerbaijani",
+	"bsn": "Barasana-Eduria", //
+	"ba":  "Bashkir",         //
+	"eu":  "Basque",
+	"be":  "Belarusian",
+	"bem": "Bemba", //
+	"bn":  "Bengali",
+	"ber": "Berber",  //
+	"bi":  "Bislama", //
+	"bs":  "Bosnian",
+	"br":  "Breton", //
+	"bg":  "Bulgarian",
+	"cjp": "Cabécar", //
+	"yue": "Cantonese",
+	"ca":  "Catalan",
+	"ceb": "Cebuano",
+	"cha": "Chamorro", //
+	"chr": "Cherokee", //
+	"ny":  "Chichewa",
+	"zh":  "Chinese (Simplified)",  // "zh-cn" on Google
+	"cht": "Chinese (Traditional)", // "zh-tw" on Google
+	"cv":  "Chuvash",
+	"cop": "Coptic", //
+	"co":  "Corsican",
+	"hr":  "Croatian",
+	"cs":  "Czech",
+	"da":  "Danish",
+	"dv":  "Dhivehi", //
+	"dik": "Dinka",   //
+	"nl":  "Dutch",
+	"dz":  "Dzongkha", //
+	"en":  "English",
+	"eo":  "Esperanto",
+	"et":  "Estonian",
+	"ee":  "Ewe",      //
+	"fo":  "Faroese",  //
+	"fj":  "Fijian",   //
+	"fil": "Filipino", // "tl" on Google
+	"fi":  "Finnish",
+	"fr":  "French",
+	"fy":  "Frisian",
+	"gbi": "Galela", //
+	"gl":  "Galician",
+	"lg":  "Ganda",    //
+	"jy":  "Georgian", // "ka" on Google
+	"de":  "German",
+	"el":  "Greek",
+	"amu": "Guerrero Amuzgo", //
+	"gu":  "Gujarati",
+	"ht":  "Haitian Creole",
+	"ha":  "Hausa",
+	"haw": "Hawaiian",
+	"he":  "Hebrew", // "iw" on Google
+	"hi":  "Hindi",
+	"mww": "Hmong Daw", //
+	"hmn": "Hmong",     // not in iciba
+	"hu":  "Hungarian",
+	"is":  "Icelandic",
+	"ig":  "Igbo",
+	"id":  "Indonesian",
+	"ga":  "Irish",
+	"it":  "Italian",
+	"jac": "Jacalteco", //
+	"ja":  "Japanese",
+	"jv":  "Javanese", // "jw" on Google
+	"kab": "Kabyle",   //
+	"kn":  "Kannada",
+	"cak": "Kaqchikel",         //
+	"ka":  "Kazakh",            // Google only has "kk"
+	"kk":  "Kazakh (Cyrillic)", // Google has it as just "Kazakh"
+	"kek": "Kekchí",            //
+	"km":  "Khmer",
+	"rw":  "Kinyarwanda",
+	"kg":  "Kongo", //
+	"ko":  "Korean",
+	"ku":  "Kurdish (Kurmanji)",
+	"ky":  "Kyrgyz",
+	"lo":  "Lao",
+	"la":  "Latin",
+	"lv":  "Latvian",
+	"ln":  "Lingala", //
+	"lt":  "Lithuanian",
+	"dop": "Lukpa", //
+	"lb":  "Luxembourgish",
+	"mk":  "Macedonian",
+	"mg":  "Malagasy",
+	"ms":  "Malay",
+	"ml":  "Malayalam",
+	"mt":  "Maltese",
+	"mam": "Mam",  //
+	"gv":  "Manx", //
+	"mi":  "Maori",
+	"mr":  "Marathi",
+	"mhr": "Mari (Eastern)", //
+	"mrj": "Mari (Western)", //
+	"mn":  "Mongolian",
+	"me":  "Montenegrin", //
+	"my":  "Myanmar (Burmese)",
+	"nhg": "Nahuatl", //
+	"djk": "Ndyuka",  //
+	"ne":  "Nepali",
+	"no":  "Norwegian",
+	"or":  "Odia (Oriya)",
+	"ojb": "Ojibwa",
+	"om":  "Oromo",      //
+	"os":  "Ossetian",   //
+	"pck": "Paite",      //
+	"pap": "Papiamento", //
+	"ps":  "Pashto",
+	"fa":  "Persian",
+	"pl":  "Polish",
+	"pt":  "Portuguese",
+	"pot": "Potawatomi", //
+	"pa":  "Punjabi",
+	"otq": "Querétaro Otomi",     //
+	"quc": "Quiché",              //
+	"quw": "Quichua",             //
+	"chq": "Quiotepec Chinantec", //
+	"rmn": "Romani",              //
+	"ro":  "Romanian",
+	"rn":  "Rundi", //
+	"ru":  "Russian",
+	"sm":  "Samoan",
+	"sg":  "Sango", //
+	"gd":  "Scots Gaelic",
+	"sr":  "Serbian",
+	"crs": "Seselwa Creole French", //
+	"st":  "Sesotho",
+	"sn":  "Shona",
+	"jiv": "Shuar", //
+	"sd":  "Sindhi",
+	"si":  "Sinhala",
+	"sk":  "Slovak",
+	"sl":  "Slovenian",
+	"so":  "Somali",
+	"es":  "Spanish",
+	"su":  "Sundanese",
+	"sw":  "Swahili",
+	"sv":  "Swedish",
+	"syc": "Syriac",    // considered "extinct" but is somehow supported
+	"shi": "Tachelhit", //
+	"ty":  "Tahitian",  //
+	"tg":  "Tajik",
+	"ta":  "Tamil",
+	"tt":  "Tatar",
+	"te":  "Telugu",
+	"tet": "Tetum", //
+	"th":  "Thai",
+	"ti":  "Tigre",     //
+	"tw":  "Tiwi",      //
+	"tpi": "Tok Pisin", //
+	"to":  "Tonga",     //
+	"ts":  "Tsonga",
+	"tn":  "Tswana", //
+	"tr":  "Turkish",
+	"tk":  "Turkmen",
+	"udm": "Udmurt", //
+	"uk":  "Ukrainian",
+	"ppk": "Uma", //
+	"ur":  "Urdu",
+	"usp": "Uspanteco", //
+	"uy":  "Uyghur",    // "ug" on Google
+	"uz":  "Uzbek",
+	"ve":  "Venda", //
+	"vi":  "Vietnamese",
+	"war": "Waray", //
+	"cy":  "Welsh",
+	"wal": "Wolaitta", //
+	"wol": "Wolof",
+	"xh":  "Xhosa",
+	"yi":  "Yiddish",
+	"yo":  "Yoruba",
+	"yua": "Yucatán Maya", //
+	"dje": "Zarma",        //
+	"zu":  "Zulu",
 }
 
-func (_ *ICIBA) SourceLanguages() ([]Language, error) { return icibaLanguages, nil }
-
-func (_ *ICIBA) TargetLanguages() ([]Language, error) { return icibaLanguages, nil }
-
-func (_ *ICIBA) SupportsAutodetect() bool { return true }
-
-func (_ *ICIBA) DetectLanguage(text string) (Language, error) { return Language{}, nil }
+func (_ *ICIBA) SourceLanguages() (Language, error) { return icibaLanguages, nil }
+
+func (_ *ICIBA) TargetLanguages() (Language, error) { return icibaLanguages, nil }
+
+func (_ *ICIBA) DetectLanguage(text string) (string, error) { return "", nil }
 
 type icibaTranslateResponse struct {
@@ -227,5 +225,5 @@
 }
 
-func (_ *ICIBA) Translate(text string, from, to Language) (TranslationResult, error) {
+func (_ *ICIBA) Translate(text string, from, to string) (TranslationResult, error) {
 	requestURL, err := url.Parse("https://ifanyi.iciba.com/index.php")
 
@@ -248,6 +246,6 @@
 
 	formData := url.Values{}
-	formData.Add("from", from.Code)
-	formData.Add("to", to.Code)
+	formData.Add("from", from)
+	formData.Add("to", to)
 	formData.Add("q", text)
 
@@ -270,15 +268,15 @@
 	}
 
-	var sourceLanguage Language
-
-	for _, lang := range icibaLanguages {
-		if lang.Code == responseJSON.Content.From {
-			sourceLanguage = lang
+	var sourceLanguage string
+
+	for code := range icibaLanguages {
+		if code == responseJSON.Content.From {
+			sourceLanguage = code
 			break
 		}
 	}
 
-	if sourceLanguage == (Language{}) {
-		return TranslationResult{SourceLanguage: from, TranslatedText: responseJSON.Content.Out},
+	if sourceLanguage == "" {
+		return TranslationResult{TranslatedText: responseJSON.Content.Out},
 			fmt.Errorf("language code \"%s\" is not in iCIBA's language list", responseJSON.Content.From)
 	}
Index: trunk/engines/language.go
===================================================================
--- trunk/engines/language.go	(revision 14)
+++ 	(revision )
@@ -1,5 +1,0 @@
-package engines
-
-type Language struct {
-	Name, Code string
-}
Index: trunk/engines/libretranslate.go
===================================================================
--- trunk/engines/libretranslate.go	(revision 14)
+++ trunk/engines/libretranslate.go	(revision 15)
@@ -28,10 +28,5 @@
 func (_ *LibreTranslate) DisplayName() string { return "LibreTranslate" }
 
-type libreLanguagesResponse []struct {
-	Name string `json:"name"`
-	Code string `json:"code"`
-}
-
-func (e *LibreTranslate) getLangs() ([]Language, error) {
+func (e *LibreTranslate) getLangs() (Language, error) {
 	response, err := http.Get(e.InstanceURL + "/languages")
 
@@ -46,5 +41,8 @@
 	}
 
-	var langsResponse libreLanguagesResponse
+	var langsResponse []struct {
+		Name string `json:"name"`
+		Code string `json:"code"`
+	}
 
 	if err := json.NewDecoder(response.Body).Decode(&langsResponse); err != nil {
@@ -52,8 +50,8 @@
 	}
 
-	langs := make([]Language, len(langsResponse))
+	langs := Language{}
 
-	for i, lang := range langsResponse {
-		langs[i] = Language{Name: lang.Name, Code: lang.Code}
+	for _, lang := range langsResponse {
+		langs[lang.Code] = lang.Name
 	}
 
@@ -62,9 +60,7 @@
 }
 
-func (e *LibreTranslate) SourceLanguages() ([]Language, error) { return e.getLangs() }
+func (e *LibreTranslate) SourceLanguages() (Language, error) { return e.getLangs() }
 
-func (e *LibreTranslate) TargetLanguages() ([]Language, error) { return e.getLangs() }
-
-func (_ *LibreTranslate) SupportsAutodetect() bool { return true }
+func (e *LibreTranslate) TargetLanguages() (Language, error) { return e.getLangs() }
 
 type libreDetectResponse []struct {
@@ -73,5 +69,5 @@
 }
 
-func (e *LibreTranslate) DetectLanguage(text string) (Language, error) {
+func (e *LibreTranslate) DetectLanguage(text string) (string, error) {
 	formData := map[string]string{"q": text}
 
@@ -83,5 +79,5 @@
 
 	if err != nil {
-		return Language{}, err
+		return "", err
 	}
 
@@ -89,5 +85,5 @@
 
 	if err != nil {
-		return Language{}, err
+		return "", err
 	}
 
@@ -95,5 +91,5 @@
 
 	if response.StatusCode != 200 {
-		return Language{}, fmt.Errorf("got status code %d from LibreTranslate API", response.StatusCode)
+		return "", fmt.Errorf("got status code %d from LibreTranslate API", response.StatusCode)
 	}
 
@@ -101,5 +97,5 @@
 
 	if err := json.NewDecoder(response.Body).Decode(&langs); err != nil {
-		return Language{}, err
+		return "", err
 	}
 
@@ -115,14 +111,14 @@
 
 	if err != nil {
-		return Language{}, err
+		return "", err
 	}
 
-	for _, lang := range engineLangs {
-		if lang.Code == maxConfidenceLang.LanguageCode {
-			return lang, nil
+	for code := range engineLangs {
+		if code == maxConfidenceLang.LanguageCode {
+			return code, nil
 		}
 	}
 
-	return Language{}, fmt.Errorf("language code \"%s\" is not in the instance's language list", maxConfidenceLang.LanguageCode)
+	return "", fmt.Errorf("language code \"%s\" is not in the instance's language list", maxConfidenceLang.LanguageCode)
 }
 
@@ -131,9 +127,9 @@
 }
 
-func (e *LibreTranslate) Translate(text string, from, to Language) (TranslationResult, error) {
+func (e *LibreTranslate) Translate(text string, from, to string) (TranslationResult, error) {
 	formData := map[string]string{
 		"q":      text,
-		"source": from.Code,
-		"target": to.Code,
+		"source": from,
+		"target": to,
 	}
 
@@ -166,4 +162,4 @@
 	}
 
-	return TranslationResult{SourceLanguage: from, TranslatedText: responseJSON.TranslatedText}, nil
+	return TranslationResult{TranslatedText: responseJSON.TranslatedText}, nil
 }
Index: trunk/engines/reverso.go
===================================================================
--- trunk/engines/reverso.go	(revision 14)
+++ trunk/engines/reverso.go	(revision 15)
@@ -15,37 +15,35 @@
 func (_ *Reverso) DisplayName() string { return "Reverso" }
 
-var reversoLangs = []Language{
-	{Name: "Arabic", Code: "ara"},
-	{Name: "Chinese (Simplified)", Code: "chi"}, // marketed as just "Chinese"
-	{Name: "Czech", Code: "cze"},
-	{Name: "Danish", Code: "dan"},
-	{Name: "Dutch", Code: "dut"},
-	{Name: "English", Code: "eng"},
-	{Name: "French", Code: "fra"},
-	{Name: "German", Code: "ger"},
-	{Name: "Hebrew", Code: "heb"},
-	{Name: "Hindi", Code: "hin"},
-	{Name: "Hungarian", Code: "hun"},
-	{Name: "Italian", Code: "ita"},
-	{Name: "Japanese", Code: "jpn"},
-	{Name: "Korean", Code: "kor"},
-	{Name: "Persian", Code: "per"},
-	{Name: "Polish", Code: "pol"},
-	{Name: "Portuguese", Code: "por"},
-	{Name: "Romanian", Code: "rum"},
-	{Name: "Russian", Code: "rus"},
-	{Name: "Slovak", Code: "slo"},
-	{Name: "Spanish", Code: "spa"},
-	{Name: "Swedish", Code: "swe"},
-	{Name: "Thai", Code: "tha"},
-	{Name: "Turkish", Code: "tur"},
-	{Name: "Ukrainian", Code: "ukr"},
+var reversoLangs = Language{
+	"ara": "Arabic",
+	"chi": "Chinese (Simplified)", // marketed as just "Chinese"
+	"cze": "Czech",
+	"dan": "Danish",
+	"dut": "Dutch",
+	"eng": "English",
+	"fra": "French",
+	"ger": "German",
+	"heb": "Hebrew",
+	"hin": "Hindi",
+	"hun": "Hungarian",
+	"ita": "Italian",
+	"jpn": "Japanese",
+	"kor": "Korean",
+	"per": "Persian",
+	"pol": "Polish",
+	"por": "Portuguese",
+	"rum": "Romanian",
+	"rus": "Russian",
+	"slo": "Slovak",
+	"spa": "Spanish",
+	"swe": "Swedish",
+	"tha": "Thai",
+	"tur": "Turkish",
+	"ukr": "Ukrainian",
 }
 
-func (_ *Reverso) SourceLanguages() ([]Language, error) { return reversoLangs, nil }
+func (_ *Reverso) SourceLanguages() (Language, error) { return reversoLangs, nil }
 
-func (_ *Reverso) TargetLanguages() ([]Language, error) { return reversoLangs, nil }
-
-func (_ *Reverso) SupportsAutodetect() bool { return true }
+func (_ *Reverso) TargetLanguages() (Language, error) { return reversoLangs, nil }
 
 type reversoAPIResponse struct {
@@ -56,10 +54,10 @@
 }
 
-func (e *Reverso) callAPI(text string, from, to Language) (reversoAPIResponse, error) {
+func (e *Reverso) callAPI(text string, from, to string) (reversoAPIResponse, error) {
 	// `contextResults` must be false for language detection
 	formData := map[string]interface{}{
 		"format": "text",
-		"from":   from.Code,
-		"to":     to.Code,
+		"from":   from,
+		"to":     to,
 		"input":  text,
 		"options": map[string]interface{}{
@@ -110,25 +108,25 @@
 }
 
-func (e *Reverso) DetectLanguage(text string) (Language, error) {
+func (e *Reverso) DetectLanguage(text string) (string, error) {
 	// Any language pair works here, does not affect result
-	r, err := e.callAPI(text, reversoLangs[0], reversoLangs[1])
+	r, err := e.callAPI(text, "ara", "chi")
 
 	if err != nil {
-		return Language{}, err
+		return "", err
 	}
 
 	langCode := r.LanguageDetection.DetectedLanguage
 
-	for _, lang := range reversoLangs {
-		if lang.Code == langCode {
-			return lang, nil
+	for code := range reversoLangs {
+		if code == langCode {
+			return code, nil
 		}
 	}
 
-	return Language{}, fmt.Errorf("language code \"%s\" is not in Reverso's language list", langCode)
+	return "", fmt.Errorf("language code \"%s\" is not in Reverso's language list", langCode)
 }
 
-func (e *Reverso) Translate(text string, from, to Language) (TranslationResult, error) {
-	if from.Code == "auto" {
+func (e *Reverso) Translate(text string, from, to string) (TranslationResult, error) {
+	if from == "auto" {
 		from_, err := e.DetectLanguage(text)
 
@@ -155,5 +153,4 @@
 
 	return TranslationResult{
-		SourceLanguage: from,
 		TranslatedText: translation,
 	}, nil
